Casa Open

O que ganho usando Jboss Seam?

2013-02-07T15:49:00.000-08:00

Texto direcionado a usuários do JSF 1.2 tratando do uso do Jboss Seam 2.x.

Para quem não conhece, o Seam é um framework destinado ao desenvolvimento WEB criado pelo mesmo criador do Hibernate, Gavin King, e que tem como um de seus principais objetivos facilitar a integração entre JSF e EJB3.

Muitos são os ganhos obtidos pelo uso do Seam, dentre estes irei me ater aos seguintes:

Menos XMLs
Requisições por GET
Facilidade na utilização de ComboBox
Injeção de Dependências via anotações
Facilidade no envio de e-mails
Agendamento de tarefas
URL user friendly
Suporte a transações
Integração com Groovy, Hibernate, Spring, entre outros

Para não estender muito, neste post irei falar dos três primeiros. Falarei dos demais em posts futuros.

1. Menos XMLs
O Seam diminui a utilização de XML em vários aspectos, como por exemplo:

1.1. Navegação
Usando apenas o JSF 1.2, a navegação entre páginas deve ser definida via XML, no arquivo faces-config.xml, e usada por meio de um método no Managed Bean que retorne um String de saída configurada no faces-config.xml. Conforme o exemplo abaixo:

faces-config.xml:

<navegation-rule>
  <from-view-id>/person/people.xhtml</from-view-id> 
  <navegation-case> 
    <from-outcome>edit</from-outcome> 
    <to-view-id>/person/edit.xhtml</to-view-id> 
  </navegation-case> 
</navegation-rule>

Managed Bean:

public String editPeople() {
  return "edit";
}

Com o Seam, isso pode ser feito de forma mais simples, apenas retornando o nome da página no método do Managed Bean.

public String editPeople() {
   return "/person/edit.xhtml";
}

1.2 Registro de Managed Beans

Para que cada Managed Bean seja utilizado nas views do JSF é necessário que este esteja registrado no faces-config.xml, como mostrado abaixo:

<?xml version="1.0" encoding="UTF-8"?>
  <faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xi="http://www.w3.org/2001/XInclude"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="htt      p://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">

  <managed-bean>
    <managed-bean-name>people</managed-bean-name>
    <managed-bean-class>br.com.People</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
  </managed-bean>

</faces-config>

Com o Seam, basta que o bean seja declarado como um componente do Seam, por meio da anotação @Name. Deste modo, o bean passar a ser gerenciado pelo Seam. Ou seja, além de ser um Managed Bean, também é um Seam Component.

@Name("people")
public class People {
  //...
}

2. Requisições por GET

O JSF 1.2 não lida bem com parâmetros GET. Não que seja impossível "capturar" tais parâmetros, mas é trabalhoso e não natural. Veja o seguinte exemplo que apresenta uma forma recuperar o parâmetro "id" passado por GET no bean:

String id = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("id"));

O Seam facilita muito esse trabalho fazendo "bind" dos parâmetros GET por meio da anotação @RequestParameter:

@RequestParameter
private Long id = null;

3. Facilidade na utilização de ComboBox

Imagine a seguinte situação: você pretende apresentar ao usuário um ComboBox com as regiões do Brasil onde cada região possui um id e um nome. Para você, é importante saber o id da região escolhida pelo usuário. Para o usuário, é importante escolher a região pelo nome, não pelo id.
Para resolver isso no JSF é necessário criar um mapa que contenha os nomes e os ids semelhante a esse:

public class MostraRegioes {

  public Map<String, Regioes> getRegioes(){
    Map<String, Regioes> regioes = new HashMap<String, Regioes>();
    for(Regioes r : Regioes.values()) {
      regioes.put(r.getNome(), 1);
    }
    return regioes;
  }

}

E usá-lo da seguinte forma:

<h:selectOneMenu>
  <f:selectItems value="#{MostraRegioes.regioes}"/>
</h:selectOneMenu>

O que não é produtivo quando temos um sistema com muitos combos. Pois teríamos que fazer um método (convertendo de lista ou Array para um mapa ou List<SelectItems>) para cada combo. Felizmente o Seam ajuda nisso com o componente <s:selectItems /> que faz binding com uma lista/array comum. Veja:

<h:selectOneMenu>
  <s:selectItems value="#{MostraRegioes.regioes}"
    var="regiao" label=#{regiao.nome}"/>
</h:selectOneMenu>

Criando validadores personalizados no JSF

2013-01-22T14:44:00.000-08:00

Cortando as introduções e indo direto ao assunto, no JSF você pode trabalhar com dois grupos de validadores de dados: os existentes (que são fornecidos pelo JSF) e os personalizados (que são os criados por você). Os existentes validam algumas características de dados, tais como: tamanho de campos, limites, entre outras. Mas, como é de se esperar, várias características não são abrangidas. Em vista disso, a possibilidade de criar validadores personalizados é uma boa saída fornecida pelo JSF.

Criando um validador

Criar um validador em JSF é simples. Para tal, basta sobrescrever o método validade(), por meio de uma classe que estenda a interface javax.faces.validator.Validator, e registrá-lo no contexto do JSF. Vejamos um exemplo de validação de e-mail.

1. Criando o validador

public void validateEmail(FacesContext context, UIComponent toValidate, Object value) {
  String email = (String) value;
  if (email.indexOf('@') == -1) {
   ((UIInput) toValidate).setValid(false);
   FacesMessage message = new FacesMessage("Invalid Email");
   context.addMessage(toValidate.getClientId(context), message);
  }
 }

2. Registrando o validador

Para registrar o validador, basta indicá-lo no Faces-config, conforme o exemplo abaixo:


 <h:inputText id="email" value="#Bean.user.email}"
  validator="#{validateEmail}" required="true"/>

3. Usando o validador

Tendo criado e registrado o validador, basta usa-lo por meio do marcador <f:validator .../>:

Ciclo de vida JSF

2012-12-28T04:36:00.002-08:00

Um dos fundamentos de maior relevância do JSF é seu ciclo de vida que se dá entre requisição e resposta do servidor de aplicação. São vários os motivos da existência deste ciclo, dentre estes, temos:

Manter o controle de estado dos componentes de interface;
Alinhar ouvintes de eventos com seus respectivos eventos;
Controle de navegação entre páginas, que deve ser realizado pelo servidor;
Permitir que validações e conversões sejam realizadas no lado do servidor.

Indo direto ao assunto, o ciclo de vida do JSF se divide em 6 fases (veja a figura abaixo), que são:

Fase 1: Restore View (Restauração da Visão)
Fase 2: Apply Request Values (Aplicar Valores da Requisição)
Fase 3: Process Validation (Processar as Validações)
Fase 4: Update Model Values (Atualizar Valores de Modelo)
Fase 5: Invoke Application (Invocar Aplicação)
Fase 6: Render Response (Renderizar a Resposta)

Ciclo de vida do JSF

Vejamos agora o que acontece em cada uma.

Fase 1: Restore View (Restauração da Visão)

A partir de uma requisição proveniente do servlet FacesServlet, é identificado qual visão está sendo requisitada por meio do ID desta que é determinado pelo nome da página JSP. Tendo identificado a página, esta é salva no FacesContext (caso ainda não tenha sido salva) e sua respectiva árvore de componentes é construída.

Fase 2: Apply Request Values (Aplicar Valores da Requisição)

Nesta fase, cada componente da visão, criado ou recuperado, passa a ter o seu valor. Nesse contexto, existem algumas diferenças ocasionadas pelo valor do atributo "immediate" em cada componente:

immediate = false: Neste caso, que é o padrão, os valores são apenas convertidos para o tipo apropriado. Se o valor é um Integer, é convertido para Integer.
immediate = true: Os valores são convertidos e validos.

Fase 3: Process Validation (Processar as Validações)

Esta é a primeira manipulação de eventos do ciclo, aqui serão executadas as validações definidas pelo servidor em cada componente. Não existindo valores inválidos, o ciclo segue para a Fase 4. Existindo, uma mensagem de erro será gerada (adicionada ao contexto do Faces, FacesContext) e o componente é marcado como inválido. Neste caso, o ciclo segue para a Fase 6 (Renderizar a resposta).

Fase 4: Update Model Values (Atualizar Valores de Modelo)

Os valores enviados pela requisição e validados pela fase 3, são atualizados em seus respectivos atributos contidos nos backings beans, onde somente as propriedades enviadas são atualizadas. É importante dizer que, mesmo após a fase de validação, fase 3, os valores enviados podem estar inválidos a nível de negócio ou a nível de conversão de tipos, o que pode ser verificado pelo próprio bean.

Fase 5: Invoke Application (Invocar Aplicação)

Nesta fase, os valores dos componentes da requisição, estão validados convertidos e disponíveis nos backings beans. Assim a aplicação tem os insumos necessários para aplicar a lógica de negócio.
Outro fator importante dessa fase, é o direcionamento do usuário de acordo com as submissões realizadas pelo mesmo. Por exemplo, se ouve sucesso no processamento dos dados enviados, o usuário é redirecionado para uma determinada página, se não, permanece na mesma página.

Fase 6: Render Response (Renderizar a Resposta)

O processo o Renderizar a Resposta consiste na apresentação da página referente ao resultado da aplicação ao usuário. Neste contexto existem três possibilidades:

Caso seja a primeira requisição da página: Os componentes associados são criados e associados a visão;
Caso seja a primeira submissão: Os componentes são traduzidos para o HTML;
Caso tenha ocorrido algum erro: Existindo os marcadores <f:message /> ou <f:messages /> na página, os erros são exibidos ao usuário.

Visão Geral

No desenvolvimento em JSF existem dois perfis diferentes de desenvolvedores: os que desenvolveram aplicações JSF e os que desenvolveram componentes. No primeiro perfil, as fases de maior foco são a 2, 3, 4 e 5. Já no segundo, são a 1 e 6, que estão mais relacionadas a árvore de componentes no lado do servidor e de componentes da visão. Sendo assim podemos agrupar as fases da seguinte forma:

Fases focadas no desenvolvimento de aplicações JSF

Fase 2: Apply Request Values (Aplicar Valores da Requisição)
Fase 3: Process Validation (Processar as Validações)
Fase 4: Update Model Values (Atualizar Valores de Modelo)
Fase 5: Invoke Application (Invocar Aplicação)

Fases focadas no desenvolvimento de componentes de visão

Fase 1: Restore View (Restauração da Visão)
Fase 6: Render Response (Renderizar a Resposta)

O padrão MVC segundo o JSF

2012-12-17T13:12:00.001-08:00

O que MVC?

O padrão MVC, de modo geral, divide uma aplicação em três camadas: modelo, visão e controle. A visão é responsável por apresentar a interface ao usuário. O modelo, pela representação dos objetos do negócio e fornecimento de acesso aos dados do negócio. E o controle define o comportamento da aplicação interpretando as ações de modo a realizar as devidas chamadas ao modelo. De modo simplificado, é dito que o controle fornece uma ligação entre visualização e modelo.

Esse padrão contribui para uma melhor separação de tarefas em uma equipe de desenvolvedores. Pois, tendo a aplicação separada por camadas, é mais fácil direcionar pessoas com habilidades diferentes para se concentrarem em partes diferentes do código.

Veja o diagrama abaixo que demostra a relação entre modelo, visão e controle onde as linhas sólidas indicam associação direta e as tracejadas indicam associação indireta.

O que é JSF?

O JavaServer Faces (JSF), é uma especificação do framework MVC Java padrão que tem como principal objetivo simplificar a construção de componentes de interface gráfica para aplicações web.

Desenvolvido pela Java Community Process (JCP), tem como uma de suas características mais relevantes a presença do modelo de componentes, semelhante ao que acontece no desenvolvimento Desktop. Essa orientação tende a facilitar o reuso pois, além dos vários componentes já existentes, é possível criar novos componentes.

Outras características marcantes são a existência de validadores e conversores de dados (facilitando a manipulação de tais), navegabilidade entre páginas oferecida por arquivos de configuração, suporte a internacionalização, entre outras.

MVC no JSF

No JavaServer Faces, o controle fica por conta de um servlet chamado Faces Servlet, por arquivos de configuração (ex.: faces-config.xml), pelos Backing Beans e pelos validadores e conversores. O Faces Servlet se designa a receber requisições, encaminhá-las ao modelo e enviar as respectivas repostas. Os arquivos de configuração são responsáveis por definirem a navegação entre páginas e o mapeamento de ações. Já os validadores e conversores permitem um maior controle sobre os dados que serão enviados. Importante ressaltar que, mesmo sendo referenciados nas páginas, os conversores e validadores fazem parte do processamento de eventos, logo também fazem parte do controlador e não da visão.

O modelo é constituído por classes de entidade e de negócio, que por sua vez, recebem dados da camada de visualização e executam regras pertinentes ao negócio.

Já a visualização, remete ao que o usuário vê, ou seja: a interface - páginas JSP e kits renderizadores (HTML, WML, XML, etc.). Mas, como o JSF se utiliza de componentes, pode se dizer que esta é composta por uma hierarquia de componentes organizados.

De modo simplificado, o MVC em aplicações web é distribuído da seguinte forma:

Visão:
• Componentes UI em páginas JSP/XHTML
• Kits renderizadores (HTML, WML, XML, etc.)

Controlador:
• Faces Servlet (Front Controller)
• Backing Bean (Page Controller ou Modelo)

Modelo:
• entidades e regras de negócio
• Objetos gerais da aplicação (dados, etc.)

Removendo acentos de String no Java

2012-11-07T15:44:00.001-08:00

Você programa a mais de um mês? Se sim, é provável que já precisou retirar acentos de um String. Para isso, existe a forma feia, chata e antipática de fazer (que por sinal é a que mais vejo) e a forma bonita e elegante (que raramente vejo).

Forma feia, chata e antipática

public String removeAcentos (String string){  
      string = string.replaceAll("[ÂÀÁÄÃ]","A");  
      string = string.replaceAll("[âãàáä]","a");  
      string = string.replaceAll("[ÊÈÉË]","E");  
      string = string.replaceAll("[êèéë]","e");  
      string = string.replaceAll("ÎÍÌÏ","I");  
      string = string.replaceAll("îíìï","i");  
      string = string.replaceAll("[ÔÕÒÓÖ]","O");  
      string = string.replaceAll("[ôõòóö]","o");  
      string = string.replaceAll("[ÛÙÚÜ]","U");  
      string = string.replaceAll("[ûúùü]","u");  
      string = string.replaceAll("Ç","C");  
      string = string.replaceAll("ç","c");   
      string = string.replaceAll("[ýÿ]","y");  
      string = string.replaceAll("Ý","Y");  
      string = string.replaceAll("ñ","n");  
      string = string.replaceAll("Ñ","N");  
      return string;  
}

Forma bonita e elegante

public static String removeAcentos(String string) {
    if (string != null){
        string = Normalizer.normalize(str, Normalizer.Form.NFD);
        string = str.replaceAll("[^\\p{ASCII}]", "");
    }
    return string;
}

PS. Na verdade existem várias formas de fazer isso.

Por que devo estudar Acessibilidade Digital?

2012-04-13T11:03:00.000-07:00

Ao se falar em acessibilidade logo vem a mente a palavra acesso. E realmente acesso tem tudo a ver com acessibilidade. Mas, o que se pode entender por acessibilidade? Quais são suas primícias? Seus benefícios? Por que profissionais de TI devem estudá-la? É exatamente em respostas a essas perguntas que esse texto é direcionado.

Imagem do Chaplin caído com a bengala na mão e de patins

O que é Acessibilidade Digital?

Primeiramente é importante dizer que Acessibilidade está relacionada em fornecer condição para utilização, com segurança e autonomia, total ou assistida, dos espaços, mobiliários e equipamentos urbanos, das edificações, dos serviços de transporte, dos dispositivos, sistemas e meios de comunicação e informação, por qualquer pessoa. De forma análoga, Acessibilidade Digital remete a Acessibilidade no ambiente virtual sendo que Acessibilidade na Web significa que qualquer pessoa, utilizando qualquer tipo de tecnologia de navegação - navegadores gráficos, textuais, especiais para sistemas de computação móvel, etc. - deve ser capaz de visitar e interagir com qualquer site, compreendendo inteiramente as informações nele apresentadas. (DIAS, Cláudia. Usabilidade na Web - criando portais mais acessíveis. RJ: Alta Books, 2003). Em sua concepção inicial, acessibilidade estava ligada a indivíduos portadores de deficiência, entretanto sua amplitude tem se estendido a qualquer barreira que possa inviabilizar o acesso a qualquer pessoa. Diante disso, vejamos agora alguns dos motivos que impelem o estudo da acessibilidade por parte dos profissionais de TI.

Grande número de pessoas com deficiência

Segundo o IBGE (Instituto Brasileiro de Geografia e Estatística) por meio do censo realizado no ano 2000 a população brasileira possui 14,5% de portadores de deficiência. Destes, 48,1% (que constituem 16,6 milhões) são deficientes visuais e 150 mil se declaram cegos, 27,1% com deficiência física, 16,6% com deficiência mental e 8,2% com deficiência auditiva.

Maior visibilidade no Google

É de conhecimento que diversos buscadores, dentre eles o Google, levam em consideração a organização do conteúdo das páginas web. Por exemplo, se uma página apresenta imagens sem texto alternativos (tag alt), conteúdo não estruturado de acordo com o grau de importância (tags title, h1,h2,h3..), frames sem página alternativa (através do elemento "noframe") e etc, essa página tende a ser classificada com menor relevância em comparação a outra que segue os padrões de acessibilidade. Ou seja, uma boa acessibilidade também contribui para uma boa visibilidade em sistemas de busca.

Valorização da cauda longa

Não é intuito deste texto o aprofundamento no estudo da Cauda Longa mas, de forma simplificada, podemos dizer que Cauda Longa remete a força das minorias. Considerando que um pequeno grupo insolado tende a não ser muito relevante, em relação ao todo. Entretanto um conjunto de pequenos grupos possui uma relevância significativa. Esse conceito ganhou força com a expansão da internet e é baseado nisto que muitas lojas virtuais estão se sobressaindo (a Amazon.com é uma prova disso), pois também disponibilizam produtos dedicados as minorias. Mas o que quero dizer com isto? Quero dizer que se você atender somente a população de deficientes auditivos talvez seu retorno não seja expressivo, mas atendendo a população de deficientes auditivos, visuais, físicos... a probabilidade de retorno expressivo pode crescer consideravelmente.

Imagem retirada do artigo "O que é Web 2.0?" acessado em

http://www.divulgardinheiro.com/divulgar-gratis-internet/internet-marketing/o-que-e-web-2-0/

Conformidade com o decreto de lei 5296

O Decreto-lei 2596 de 2 de dezembro de 2004, também conhecido como Lei de Acessibilidade, tem por finalidade regulamentar o atendimento a indivíduos com deficiência em diversos aspectos, dentre estes o de comunicação e informação. Sendo que portais e sites da administração pública são obrigados a se tornarem acessíveis para o uso das pessoas portadoras de deficiência visual. Logo, se você trabalha em projetos web para o governo, estes projetos devem ser acessíveis.

Proteção contra processos

O primeiro caso oficial de processo motivado por acessibilidade digital foi direcionado ao Comitê de Organização dos Jogos Olímpicos de Sydney. Na ocasião Bruce Lindsay Maguire processou o comitê pela falta de acessibilidade em seu site. Fato é que atualmente vários países possuem leis específicas que tratam a questão da acessibilidade: na Inglaterra existe a DDA, nos EUS a ADA e a Seção 508, e na Austrália a DDA. Assim sendo, seguir os padrões de acessibilidade reduz significavelmente o risco de eventuais processos.

Conclusão

A acessibilidade digital tem ganhado força nos últimos anos e tudo leva a crer que este é um caminho sem volta. Particularmente acredito que, de forma semelhante ao crescimento das políticas de sustentabilidade, salvo as devidas proporções, acessibilidade chegará a um patamar de relevância significante. De modo que é impraticável ignorar as consequências e implicações que tão assunto sugere.

Você "vai" ao Ruby Masters Conf?

2011-02-11T04:13:00.000-08:00

A Ruby Masters Conf foi uma das iniciativas mais legais que vi recentemente na comunidade Ruby. Ela se trata de um conjunto de palestras que serão transmitidas on-line nos dias 25 e 26 de fevereiro de 2011 onde toda a renda será revertida para dois projetos: o RubyInstaller - que é uma ferramenta usada para instalar o ambiente necessário para o Ruby no Windows - e o Passenger - que mudou a forma da comunidade administrar um cluster de Mongrels ou gerenciar processos FastCGI.

Para participar, basta fazer sua inscrição no RubyMastersConf.com por um valor simbólico acima de R$35,00. Após a inscrição, é só esperar por ótimas palestras de pessoas muito conceituadas no mundo Ruby, como por exemplo:

E ai? Nos "encontraremos" na Ruby Masters Conf?

Saiba mais visitando o site RubyMastersConf.com

Um ano de Casa Open

2011-01-27T09:40:00.000-08:00

Este é um dia muito especial para mim pois há um ano atrás o primeiro post, intitulado Ruby on Rails vs Java, do blog, que antigamente chamava-se railsopen.blogspot.com, foi ao ar. Desde então, muita coisa mudou: alterei o layout, o domínio (veja esse post)... mas o que permanece é o foco: Ruby e Rails.

Sim, aprendi muito, errei alguns vezes, conhece pessoas e cresci. Bom, mas para comemorar essa data especial separei os 10 artigos mais lidos deste primeiro ano do Casa Open:

Também não poderia deixar de agradecer aos leitores, aos que fazem comentários, aos assinantes do feed, os seguidores do twitter e a todos que de alguma forma fazem o blog evoluir. Obrigado!

Os railers e suas músicas

2011-01-05T02:12:00.000-08:00

Em quase todos os grandes eventos de Ruby e Rails estamos tendo o privilegio imensurável de desfrutarmos do talento musical dos railers. Como sou uma boa pessoa, não irei privá-lo destes momentos inusitados...
...deixando de lado a ironia, realmente é muito bom ouvir música nos eventos e as que você verá nos próximos vídeos são ótimas!

Regaae do Node
Apresentado na RubyConf Brasil 2010.
By @danicuki, @luizfaias, @ucoaaa e @andrefaria.

Melô do Teste Automatizado e Samba do Akita
Melô do Teste Automatizado e Samba do Akita apresentado no Rails Summit 2009 por Daniel Cukier

Forro do Elomar

Forro do Elomar no Oxente Rails em 2010

Retrospectiva 2010

2010-12-26T04:43:00.000-08:00

Antes de qualquer coisa desejo, sinceramente, a todos os leitores um ótimo 2011. Que seja um ano excelente profissionalmente e pessoalmente. Me vejo também no dever de agradecê-los pelas críticas, elogios e pelos comentários - são eles que me dão forças para continuar.

Salvo os devidos agradecimentos, vamos ao que interessa. Este foi um ótimo ano pra mim e para o blog Casa Open. Foi o ano de estreia do Blog, e tudo que é novo, é especial. Mas para evitar o muito falar, vejam um resumo sobre os artigos mais interessantes - segundo os meus olhos - que aqui foram publicados.

Janeiro
Ruby on Rails vs Java
Arquivos em Ruby

Fevereiro
Gráficos no Rails - CSS Graphs
Traduzindo datas no Rails
Lendo URL's no Ruby

Março
Operador ternário e Ruby
Working with Rails ultrapassa a marca de 17000 programadores

Abril
Tarefas em background - delayed job
Precedência em operadores lógicos

Maio
Interpretador Ruby Online

Junho
Em qual ambiente estamos?

Julho
Project Euler #1
Teste suas expressões regulares na web

Agosto
progzoo.net: Comparando as linguagens de programação

Setembro
Retirando a exceção InvalidAuthenticityToken
Tipagem em Ruby

Outubro
Respostas HTTP
RubyConf Brasil 2010

Novembro
Captura de código ASCII no Ruby

Dezembro
Sockets em Ruby

No mais, tenham um bom final de ano e um 2011 melhor ainda!

Sockets em Ruby

2010-12-15T05:49:00.000-08:00

Este é primeiro de vários artigos que irei publicar sobre Sockets em Ruby. Mas antes de qualquer coisa, é conveniente dizer o que são Sockets:

A grosso modo, são as extremidades de um canal de comunicação bidirecional. Ou seja, você pode utilizar Sockets para fazer comunicação entre processos de uma maquina, entre maquinas diferentes e entre processos de maquinas diferentes.

O que iremos fazer?

Como este é o primeiro artigo sobre o tema, pretendo ir direto ao ponto, mostrando, de forma simples, como implementar uma aplicação Cliente-Servidor. Nesta aplicação o cliente envia uma mensagem para o servidor e este responde. Sendo a comunicação entre cliente e servidor realizada via Socket através do protocolo TCP.
Então, sem mais delongas, vamos aos códigos:

Servidor

# file server.rb
require 'socket' 

server = TCPServer.open(3001)  # Abre socket em escuta na porta 3001  
loop { # o servidor nunca morre, fica sempre executando
  client = server.accept      # aceita conexão do cliente
  msg_cliente = client.recvfrom( 10000 ) # recebe mensagem - 10000 bytes - do cliente

  puts  "Mensagem do cliente: #{msg_cliente}" # imprime a mensagem do cliente no servidor
  client.puts "Ola cliente eu, o servidor, recebi sua mensagem" #envia uma mensagem ao cliente    
  client.close # fecha conexão
}

Cliente

# file client.rb
require 'socket'

server = TCPSocket.open('localhost', 3001) # conecta ao servidor na porta 3001
server.puts "Ola servidor eu, o cliente, estou enviando uma mensagem" # envia mensagem para o servidor

resp = server.recvfrom( 10000 ) # recebe a mensagem -10000 bytes - do servidor
puts resp

server.close # Fecha a conexão com o servidor

Como rodar a aplicação?

Primeiro salve o código do servidor em um arquivo .rb - por exemplo server.rb - e execute o arquivo - ruby server.rb. Neste ponto o servidor está esperando a conexão de um cliente. Agora salve o código do cliente de forma análoga e execute em outro terminal de modo que cliente e servidor sejam rodados ao mesmo tempo. A partir de então o cliente envia uma mensagem ao servidor e o servidor responde.

Conclusões

Este é um exemplo simples do que pode ser feito com Sockets, espero que te ajude em algo.

Referência
http://www.tutorialspoint.com/ruby/ruby_socket_programming.htm

Captura de código ASCII no Ruby

2010-11-30T04:24:00.000-08:00

Existem vários modos para capturar os código ASCII dos caracteres em Ruby, vejamos alguns deles:

puts ?R, ?u, ?b, ?y

puts "R"[0], "u"[0], "b"[0], "y"[0]

"Ruby".each_byte { |x| p x}

Mas se você preferir fazer o caminho inverso, este método resolve:

 puts 82.chr, 117.chr, 98.chr, 121.chr

Referência:

http://en.wikibooks.org/wiki/Ruby_Programming/ASCII1

RubyConf Brasil

2010-10-31T18:39:00.000-07:00

Dois dias intensos de Ruby em São Paulo onde mais de 700 pessoas tiveram o privilegio de conhecer um pouco mais deste mundo que a muitos fascinam. Por lá estive e deixo aqui alguns dos meus pensamentos sobre o evento.

A RubyConf Brasil foi algo que realmente vai deixar saudades, um evento onde pessoas de peso marcaram presença, onde o nível dos palestrantes e palestras foram altíssimos. Estes fatos, sem dúvida, deixam a comunidade cada dia mais orgulhosa de se e dos seus feitos.

Eu e muitos mineiros fomos. Se você foi, garanto que viu alguém com a camisa do grupo Rails-MG. Nisto agradeço ao Gabriel Sobrinho - @sobrinho, que arrumou uma correria para disponibilizar as camisas à todos integrantes do grupo.

Como disse anteriormente, o nível das palestras foi sensacional, mas dentre estas irei falar especialmente de três:

palestra: Desenvolvimento de Aplicações Sociais com Rails

Carlos Brando falou sobre suas experiências no desenvolvimento de aplicações para software social em sistemas como Open Social - Orkut - e FaceBook. Ele mostrou uma forma prática, produtiva e sustentável para desenvolver aplicações sociais em Rails. Sendo a única coisa ruim a notícia de que o framework que facilita o desenvolvimento destas aplicações que o Carlos anda trabalhando não terá o código fonte aberto, pois foi vendido.

Palestra: Integrando o iPhone com Ruby on Rails + Geração de gráficos com Ruby on Rails

Essa palestra realmente me impressionou, Pedro Franceschi, de apenas 13 anos que já impactou o mundo dos iPhones - desbloqueando vários deles, mostrou que idade não é documento palestrando sobre seus conhecimentos em RoR.

Palestra: JRuby: O Melhor dos Dois Mundos

Charles Nutter, mostrou de modo prático como integrar o mundo Java e Ruby. Um ótimo ponto dessa palestra foram as demonstrações desta integração, como por exemplo o uso de bibliotecas gráficas do Java no Ruby, e o humor de Charles.

Esta foi a primeira, de muitas, RubyConf Brasil. Deixo minhas gratificações a todos que contribuíram para o evento em especial ao Fabio Akita e aos patrocinadores: Go Now, thoughtworks, Caelum, Engine Yard, Pay Pal e Infoq.

Mural RubyConf Brasil

Respostas HTTP

2010-10-25T05:39:00.000-07:00

Quando fazemos uma requisição na Web, o servidor busca o que está sendo requisitado e envia uma resposta para quem fez a requisição. Esta resposta pode ser dos seguintes tipos:

1XX: informativas;

2XX: indicam sucesso;

3XX: referem-se a um redirecionamento;

4XX: indicam erros ocorridos no cliente;

5XX: indicam erros no servidor.

Mas como obter estas respostas através do Ruby? O seguinte código responde à essa pergunta:

require 'net/http' 
  resposta = Net::HTTP.get_response(URI.parse("http://www.casaopen.com.br/"))
  puts resposta.code  # retorna qual foi a resposta a requisição HTTP. Ex: 200, 400...

Mas como você não quer problemas caso a URL os tenha, isso ajuda:

require 'net/http' 
begin
  resposta = Net::HTTP.get_response(URI.parse("http://www.casaopen.com.br/"))
  puts resposta.code  # retorna qual foi a resposta a requisição HTTP. Ex: 200, 400...
rescue => ret   # TimeoutError #  Net::HTTP.SocketError,
  puts  "Erro: #{resposta}"
end

Para maiores informações, veja a documentação do Ruby.

Tipagem em Ruby

2010-09-23T17:25:00.000-07:00

Cada linguagem de programação tem sua forma de lidar com tipos, por exemplo: C é uma linguagem estaticamente tipada, pois o tipo da variável é definido em tempo de compilação. O que pode ser visto no seguinte exemplo:

  char a= 'a';

No entanto, Ruby é dinamicamente, implicitamente e fortemente tipada. Vejamos o que cada um destes adjetivos significam:

Dinamicamente tipada

Quer dizer que, a cada interação, o tipo é verificado. Isso fica claro no seguinte exemplo:

x = 100
(1..4).each{ x = x * 100 ;  puts "#{ x.class} #{x}"  }

Que gera o resultado:

Fixnum 10000
Fixnum 1000000
Fixnum 100000000
Bignum 10000000000

Como podemos ver a variável x começa como Fixnum e conforme aumenta passa para Bignum sem a necessidade de uma conversão.

Essa característica gera vários pontos positivos na linguagem, tais como:

Diminui a verbosidade, pois não há a necessidade de fazer conversões;
Tende a facilitar a vida do programador pois não há a preocupação com conversões.

Mas neste contexto nem tudo são flores, vejamos os pontos negativos:

A linguagem tende a ser mais lenta, em tempo de execução, devido ao fato de que, a cada interação, o tipo ser verificado;
Pode confundir o programador pois o mesmo pode não saber exatamente com quais tipos está tratando.

Implicitamente tipada

Continuando no mesmo exemplo, quando fizemos x = 100 não precisamos declarar o tipo de x. Ou seja, não foi necessário fazer algo como: Fixnum x = 100. Isso acontece pelo fato do Ruby detectar o tipo de cada variável em tempo de execução. Uma boa analogia para este fenômeno é pensar nas variáveis como se fossem caixas fechadas e seus dados como fitas coloridas onde o interpretador abre a caixa e verifica as cores das fitas.

Novamente, os pontos positivos e negativos são muito semelhantes aos relacionados a tipagem dinâmica. Veja:

Positivos:

Diminui a verbosidade, pois não há a necessidade de fazer declarações.

Negativos:

A linguagem tende a ser mais lenta pois o tipo é verificado em tempo de execução de acordo com a analogia das caixas e fitas;
Pode confundir o programador pois o mesmo pode não saber exatamente com quais tipos está tratando já que não existe a declaração dos mesmos.

Fortemente tipada

Este é um conceito confuso, mas uma boa forma de explica-lo é dizendo que todas as variáveis devem ter um tipo - ou seja: fazer parte de uma classe no caso do Ruby - e que cada tipo segue a risca seu contrato. Por exemplo:

a = 100
b = "Ruby on Rails"
a + b

TypeError: String can't be coerced into Fixnum
    from (irb):54:in `+'
    from (irb):54

Como você notou, em Ruby não podemos somar um String com Fixnum pois essa operação não está no contrato da classe String e Fixnum.

De fato, o assunto não acaba por aqui, existem alguns materiais na Web e em Livros sobre isso. Em vista disso, e no intuito de incentivar a pesquisa, deixo algumas referencias e até a próxima!

P.S. Os tipos em Ruby na verdade são classes, ou seja: não existem tipos primitivos e sim objetos que pertencem a classes. Ex.:

a = 1 # a pertence a classe Fixnum

Retirando a exceção InvalidAuthenticityToken

2010-09-09T07:22:00.000-07:00

Já tentou enviar formulários fora da sua aplicação? Se sim, certamente você teve problemas!

Esses problemas se devem ao fato de que o Rails 2 insere o campo “authenticity_token” nos formulários no intuito de não permitir envios de forms por terceiros.

Mas se desejar receber tais envios basta colocar:

self.allow_forgery_protection = false

no controller desejado.

progzoo.net: Comparando as linguagens de programação

2010-08-17T07:12:00.000-07:00

O progzoo.net é um ótimo site que mostra códigos com o mesmo propósito em linguagens diferentes - Java, C#, C++, Perl, PHP, Python, Ruby, VB. O site fornece exemplos tais como o Hello World, Convert to Number, Read Text File, Sum an Array entre outros.

E, puxando a sardinha para o Ruby, é impressionante o quanto ele é mais conciso do que a maiorias das outras linguagens.

Sem dúvida vale a pena conferir o site

Teste suas expressões regulares online

2010-07-28T06:12:00.000-07:00

Vai uma dica de um ótimo site, o Rubular. Com ele você testa suas expressões regulares em Ruby de forma pratica e rápida e ainda pode adquirir um link de seus testes.

Veja um exemplo: http://rubular.com/r/tgTEBeNhzz

Project Euler #1

2010-07-16T05:57:00.001-07:00

O Projeto Euler foi iniciado por Colin Hughes (aka Euler) em outubro de 2001 e consiste em diversos problemas que envolvem matemática e computação, sendo que alguns são possíveis resolver sem o uso da computação e outros não. Segundo a descrição do projeto, este teve como principal motivação oferecer uma plataforma para que mentes curiosas mergulhem em áreas desconhecidas.

Salvo as devidas explicações, irei começar a resolver alguns problemas, de preferência em Ruby, e postar as soluções aqui.

Então... vamos ao problema 1:

Descrição

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Solução

sum = 0
(1..999).each { |x| sum += x if x%3 == 0 or x%5 == 0 }
puts sum

sum = (0..999).inject {|aux, n| ( n%3 == 0 or n%5 == 0 ) ? aux + n  : aux }
p sum

Resposta

233168

Doc da sua aplicação Rails

2010-07-08T13:51:00.000-07:00

Já experimentou o comando rake doc:app ?

rake doc:app

Ele cria uma doc semelhante a documentação do Ruby com todos os arquivos, classes e métodos da sua sua aplicação no diretório /doc/app/ .

Bom, mas existem muitos outros comandos interessantes, para conhecê-los basta rodar:

rake -T


rake db:abort_if_pending_migrations        # Raises an error if there are pending migrations
rake db:charset                            # Retrieves the charset for the current environment's database
rake db:collation                          # Retrieves the collation for the current environment's database
rake db:create                             # Create the database defined in config/database.yml for the current RAILS_ENV
rake db:create:all                         # Create all the local databases defined in config/database.yml
rake db:drop                               # Drops the database for the current RAILS_ENV
rake db:drop:all                           # Drops all the local databases defined in config/database.yml
rake db:fixtures:identify                  # Search for a fixture given a LABEL or ID.
rake db:fixtures:load                      # Load fixtures into the current environment's database.
rake db:migrate                            # Migrate the database through scripts in db/migrate and update db/schema.rb ...
rake db:migrate:down                       # Runs the "down" for a given migration VERSION.
rake db:migrate:redo                       # Rollbacks the database one migration and re migrate up.
rake db:migrate:reset                      # Resets your database using your migrations for the current environment
rake db:migrate:up                         # Runs the "up" for a given migration VERSION.
rake db:reset                              # Drops and recreates the database from db/schema.rb for the current environm...
rake db:rollback                           # Rolls the schema back to the previous version.
rake db:schema:dump                        # Create a db/schema.rb file that can be portably used against any DB support...
rake db:schema:load                        # Load a schema.rb file into the database
rake db:seed                               # Load the seed data from db/seeds.rb
rake db:sessions:clear                     # Clear the sessions table
rake db:sessions:create                    # Creates a sessions migration for use with ActiveRecord::SessionStore
rake db:setup                              # Create the database, load the schema, and initialize with the seed data
rake db:structure:dump                     # Dump the database structure to a SQL file
rake db:test:clone                         # Recreate the test database from the current environment's database schema
rake db:test:clone_structure               # Recreate the test databases from the development structure
rake db:test:load                          # Recreate the test database from the current schema.rb
rake db:test:prepare                       # Check for pending migrations and load the test schema
rake db:test:purge                         # Empty the test database
rake db:version                            # Retrieves the current schema version number
rake doc:app                               # Build the RDOC HTML Files
rake doc:clobber_app                       # Remove rdoc products
rake doc:clobber_plugins                   # Remove plugin documentation
rake doc:clobber_rails                     # Remove rdoc products
rake doc:guides                            # Generate Rails guides
rake doc:plugins                           # Generate documentation for all installed plugins
rake doc:plugins:brazilian-rails           # Generate documentation for the brazilian-rails plugin
rake doc:plugins:human_attribute_override  # Generate documentation for the human_attribute_override plugin
rake doc:plugins:jrails                    # Generate documentation for the jrails plugin
rake doc:plugins:paperclip                 # Generate documentation for the paperclip plugin
rake doc:plugins:will_paginate             # Generate documentation for the will_paginate plugin
rake doc:rails                             # Build the RDOC HTML Files
rake doc:reapp                             # Force a rebuild of the RDOC files
rake doc:rerails                           # Force a rebuild of the RDOC files
rake gems                                  # List the gems that this rails application depends on
rake gems:build                            # Build any native extensions for unpacked gems
rake gems:build:force                      # Force the build of all gems
rake gems:install                          # Installs all required gems.
rake gems:refresh_specs                    # Regenerate gem specifications in correct format.
rake gems:unpack                           # Unpacks all required gems into vendor/gems.
rake gems:unpack:dependencies              # Unpacks all required gems and their dependencies into vendor/gems.
rake jrails:install:javascripts            # Installs the jQuery and jRails javascripts to public/javascripts
rake jrails:update:javascripts             # Copies the jQuery and jRails javascripts to public/javascripts
rake log:clear                             # Truncates all *.log files in log/ to zero bytes
rake middleware                            # Prints out your Rack middleware stack
rake notes                                 # Enumerate all annotations
rake notes:custom                          # Enumerate a custom annotation, specify with ANNOTATION=WTFHAX
rake notes:fixme                           # Enumerate all FIXME annotations
rake notes:optimize                        # Enumerate all OPTIMIZE annotations
rake notes:todo                            # Enumerate all TODO annotations
rake paperclip:clean                       # Cleans out invalid attachments.
rake paperclip:refresh                     # Refreshes both metadata and thumbnails.
rake paperclip:refresh:metadata            # Regenerates content_type/size metadata for a given CLASS (and optional ATTA...
rake paperclip:refresh:thumbnails          # Regenerates thumbnails for a given CLASS (and optional ATTACHMENT).
rake rails:freeze:edge                     # Lock to latest Edge Rails, for a specific release use RELEASE=1.2.0
rake rails:freeze:gems                     # Lock this application to the current gems (by unpacking them into vendor/ra...
rake rails:template                        # Applies the template supplied by LOCATION=/path/to/template
rake rails:unfreeze                        # Unlock this application from freeze of gems or edge and return to a fluid u...
rake rails:update                          # Update both configs, scripts and public/javascripts from Rails
rake rails:update:application_controller   # Rename application.rb to application_controller.rb
rake rails:update:configs                  # Update config/boot.rb from your current rails install
rake rails:update:generate_dispatchers     # Generate dispatcher files in RAILS_ROOT/public
rake rails:update:javascripts              # Update your javascripts from your current rails install
rake rails:update:scripts                  # Add new scripts to the application script/ directory
rake routes                                # Print out all defined routes in match order, with names.
rake secret                                # Generate a crytographically secure secret key.
rake stats                                 # Report code statistics (KLOCs, etc) from the application
rake test                                  # Run all unit, functional and integration tests
rake test:benchmark                        # Run tests for benchmarkdb:test:prepare / Benchmark the performance tests
rake test:functionals                      # Run tests for functionalsdb:test:prepare / Run the functional tests in test...
rake test:integration                      # Run tests for integrationdb:test:prepare / Run the integration tests in tes...
rake test:plugins                          # Run tests for pluginsenvironment / Run the plugin tests in vendor/plugins/*...
rake test:profile                          # Run tests for profiledb:test:prepare / Profile the performance tests
rake test:recent                           # Run tests for recentdb:test:prepare / Test recent changes
rake test:uncommitted                      # Run tests for uncommitteddb:test:prepare / Test changes since last checkin ...
rake test:units                            # Run tests for unitsdb:test:prepare / Run the unit tests in test/unit
rake time:zones:all                        # Displays names of all time zones recognized by the Rails TimeZone class, gr...
rake time:zones:local                      # Displays names of time zones recognized by the Rails TimeZone class with th...
rake time:zones:us                         # Displays names of US time zones recognized by the Rails TimeZone class, gro...
rake tmp:cache:clear                       # Clears all files and directories in tmp/cache
rake tmp:clear                             # Clear session, cache, and socket files from tmp/
rake tmp:create                            # Creates tmp directories for sessions, cache, sockets, and pids
rake tmp:pids:clear                        # Clears all files in tmp/pids
rake tmp:sessions:clear                    # Clears all files in tmp/sessions
rake tmp:sockets:clear                     # Clears all files in tmp/sockets

Em qual ambiente estamos?

2010-06-30T06:16:00.000-07:00

Já teve a necessidade de saber em qual ambiente de trabalho - production, development, test e etc - você está? Acredito que sim! Logo segue algumas dicas para saber isso:

if Rails.env == 'development'
  puts 'Estamos no development'
elsif Rails.env == 'production'
  puts 'Estamos no production'
end

Ou:

puts 'Estamos no development' if Rails.env.development? 
puts 'Estamos no production' if Rails.env.production? 
puts  'Estamos no test' if Rails.env.test?  
puts  'Estamos no whatever' if Rails.env.whatever?

Ou usando a variável de ambientes RAILS_ENV:

if RAILS_ENV == 'development'
  puts 'Estamos no development'
elsif RAILS_ENV == 'production'
  puts 'Estamos no production'
end

Wallpaper Ruby on Rails

2010-06-04T10:48:00.000-07:00

Estava procurando um papel de parede novo e olhe o que encontrei:
[ P.S. basta clicar nas fotos para ser redirecionado aos devidos sites ]

Interpretador Ruby Online

2010-05-13T09:52:00.000-07:00

Já passou pela experiência de querer executar algum algoritmo mas estava sem o devido interpretador ou compilador? Certamente sim! Mas nessas horas o site CodePad é uma ótima saída, com ele você pode interpretar/compilar código fonte de várias linguagens tais com: Ruby, PHP, C, C++, Haskell, Lua, Ocaml, Perl e outras. Além disso, ele disponibiliza o seu código juntamente com a respectiva saída através de uma url curta de forma semelhante as usadas no Twitter.
Sem dúvida esses fatores apontam o CodPad como uma boa maneira para mostrar, de forma rápida, um código simples para alguém.

Interessou? Então entre no site e/ou veja como é o seu funcionamento.

P.S. Fiz alguns testes em Ruby e em todos tive sucesso, veja um deles http://codepad.org/QrVXq8oj.

Precedência em operadores lógicos

2010-04-30T06:41:00.000-07:00

Antes de qualquer coisa, veja os seguintes códigos e seus respectivos retornos:

true and false #=> false
true && false #=> false

true or false #=> true
true || false #=> true

Em vista disso, logo vem a pergunta: Qual a diferença entre "and" e "&&" e entre "or" e "||"?
A resposta é simples, "&&" e "||" possuem maior precedência que "and" e "or". Sendo que o "&&" possui maior precedência que o "||" e o "and" possui a mesma precedência que "or". Veja alguns exemplos:

true or false and false #=> false

Neste caso o código é resolvido da esquerda para a direita, ou seja: primeiro o "or" e em seguida o "and".

true or false && false #=> true

Como o "&&" possui maior precedência ele é resolvido primeiramente e depois o "or".

Tarefas em background - delayed job

2010-04-18T08:01:00.000-07:00

Realizar tarefas em background é uma boa saída para melhorar a resposta da sua aplicação. Geralmente usamos este recurso para tarefas como enviar e-mail, redimensionar imagens, postar algo no twitter... isso, simplesmente pelo fato que estas tarefas não necessitarem de resposta imediata para o usuário continuar usando o sistema.
A verdade é que, para quem utiliza Rails, existem vários plugins e gens que fazem este trabalho. Vejamos alguns:

Introducing Resque
background-fu
Backgroundjob
background_lite
backgroundrb

Porem, na minha opnião, a melhor opção é o Delayed Job. Com ele você armazena os jobs em uma tabela e os realiza quando achar melhor! Sem contar que o Delayed Job está disponível nas formas de plugin e gem. Vejamos o seu funcionamento:

Para instalar:

# instação como plugin 
# rode na raiz da aplicação
script/plugin install git://github.com/collectiveidea/delayed_job.git

Configurando o banco de dados

Para gerar a tabela onde as tarefas serão salvas use os seguintes comandos no terminal:

 script/generate delayed_job
 rake db:migrate

Isso vai gerar uma tabela no seguintes moldes:

create_table :delayed_jobs, :force => true do |table|
  table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
  table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
  table.text     :handler                      # YAML-encoded string of the object that will do work
  table.text   :last_error                   # reason for last failure (See Note below)
  table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
  table.datetime :locked_at                    # Set when a client is working on this object
  table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
  table.string   :locked_by                    # Who is working on this object (if locked)
  table.timestamps
end

Realizando tarefas em background

Agora já é possível realizar jobs em background, veja um exemplo de envio de e-mail:

# usando o Delayed Job
MeuModelDeEmail.send_later :deliver_MeuEmail, @MeuParametro

# sem usar o Delayed Job:
MeuModelDeEmail.deliver_MeuEmail(@MeuParametro)

Outro exemplo:

@imagem.calculate_size # sem usar o Delayed Job
@imagem.send_later(:calculate_size) # usando o Delayed Job

Mais um exemplo

Outro modo seria passar a(s) tarefa(s) para uma lib onde teríamos um arquivo, por exemplo: lib/mailingenvia.rb, da seguinte forma:

require 'net/smtp'
class Mailingenvia < Struct.new( MeuParametro )
  def perform
   Contato.deliver_MeuEmail( MeuParametro )
  end
end

e chamá-lo assim:

Delayed::Job.enqueue Mailingenvia.new( @MeuParametro )
# P.S. Quando isso é feito o método perform é chamado

Realizando as tarefas que estão na fila de prioridade

Quando fazemos um tarefa pelo delayed job ela é salva na tabela chamada "delayed_jobs" e para rodá-la é necessário o seguinte comando:

rake jobs:work
# para parar de realizar os jobs: CRTL-C

Se desejar apagar todas as tarefas da fila:

rake jobs:clear

Bom, é isso. Para maiores informações veja a página do daleyd job no github ou asista este screencast que eu recomendo fortimente! Até a proxima!