Fabricio DEV

Instalando MongoDB no windows

2012-11-24T07:13:00.001-08:00

É um fato que os "bancos de dados" chamados NoSQL(Not only Sql) estão ganhando cada vez mais destaque, pela sua versatilidade e performance. São implementações para armazenar tipos de dados específicos como: key-value (redis, riak), document(CouchDB, MongoDB), column family(Cassandra, H-Base), graph(Neo4j).

Eu optei por experimentar o MongoDB, pois além de ser um dos mais populares, o mesmo possui opção de download para windows 32-bit e 64bit, e também existem driver's disponíveis para Delphi, são eles: TMongoWire, pebongo e também um driver de minha autoria mongo-delphi-driver. Hoje vou me ater apenas a instalação e acesso ao MongoDB pelo shell, mais num próximo artigo vou abordar o consumo do serviço pelo Delphi.

Confira aqui os demais drivers existentes e tutoriais específico de cada driver.

Você pode baixar a instalador compatível com o seu SO aqui. E reforçando o aviso do site, a versão de 32-bit suporta algo em torno de 2GB de dados, portanto, deve ser utilizada apenas para testes. Se você for utilizar Windows Server 2008 R2 x64, Windows 7 x64, ou Windows 8 x64, há um build específico otimizado para estas versões.

Depois de fazer o download do MongoDB, descompacte o arquivo em um local de sua preferência. Na pasta bin, vem um conjunto de componentes e utilitários, conforme segue:

COMPONENTS
  bin/mongod - The database process.
  bin/mongos - Sharding controller.
  bin/mongo  - The database shell (uses interactive javascript).

UTILITIES
  bin/mongodump         - MongoDB dump tool - for backups, snapshots, etc..
  bin/mongorestore      - MongoDB restore a dump
  bin/mongoexport       - Export a single collection to test (JSON, CSV)
  bin/mongoimport       - Import from JSON or CSV
  bin/mongofiles        - Utility for putting and getting files from MongoDB GridFS
  bin/mongostat         - Show performance statistics

Aqui vamos usar apenas o mongod e mongo. Por padrão, o mongodb armazena os dados na pasta "\data\db", e você precisa criar esse diretório manualmente, ele não cria de forma automática. Eu particularmente, prefiro deixar dentro da pasta onde estão instalado o mongo, ficando assim:

Para que ele reconheça o diretório, é preciso passar o parâmetro "--dbpath [dir]" na inicialização do banco de dados. Também é possível modificar a porta que ele deve usar. Para consultar as demais configurações, utilize "mongod --help". O comando abaixo inicia o serviço:

$ mongod --dbpath C:\mongodb\data\db --port 27017 --verbose

Feito isso, você deve visualizar uma saída como essa, indicando que o servidor foi iniciado e está aguardando conexões:

C:\mongodb\bin>mongod --dbpath c:\mongodb\data\db --port 27017
(...)
(...)
(...)
[initandlisten] waiting for connections on port 27017

Agora podemos brincar com o shell interativo. Execute o aplicativo mongo.exe e será aberto um shell conectado ao database "test", que é o default. Então digite os comandos abaixo para ver o resultado.

C:\> cd \mongodb\bin
C:\mongodb\bin> mongo
MongoDB shell version: 2.0.2
> db //mostra o database atual
test
> db.foo.insert( { a : 1 } ) //Cria a collection "foo" e  insere um documento com a chave/valor a=1
> db.foo.find() //Lista todos os objetos inserido na collection
{ _id : ..., a : 1 }
> db.foo.insert( { b : 2 } ) //Insere um segundo objeto
> db.foo.find()
{ _id : ..., a : 1 }
{ _id : ..., b : 2 }
> show dbs //lista os databases existentes
local   (empty)
test    0.03125GB
> show collections //lista as collections existentes
foo
system.indexes
> help //Mostra os demais comandos disponíveis

Por isso era isso, em breve trago exemplos de como efetuar esse acesso pelo Delphi.

Instalando Indy 10 no Delphi 7

2012-09-23T18:38:00.001-07:00

Olá, recentemente surgiu a necessidade de consumir recursos REST utilizando o Delphi, no caso a versão XE2, mas muitos projetos ainda utilizam delphi 7. O Delphi XE2 vem com a versão 10 da biblioteca Indy, e funcionou muito bem, e quando fui testar no Delphi 7, que vem com Indy 9, surgiram vários problemas na manipulação dos códigos de retorno HTTP, e para resolver isso decidi atualizar a versão da biblioteca indy do Delphi 7, da versão 9 para a versão 10.

Para começar baixe a versão mais recente através do endereço http://indy.fulgan.com/ZIP, no momento desta publicação, a última versão disponível é o build 4782.

No Delphi 7, vá na opção Component\Install Packages, localize a biblioteca Indy conforme a imagem abaixo, e remova a biblioteca clicando no botão Remove.

Feche o Delphi, pois é preciso remover as referências do Indy 9 na pasta de instalação do delphi. Vá até a pasta onde o delphi está instalado, por padrão "C:\Program Files\Borland\Delphi7". Renomeie os arquivos do Indy adicionando o sufixo indy9, caso você queirar restaurar em outro momento, ou apague os arquivos se sentir a vontade. Deve ficar conforme segue:

Bin\indy70.bpl para Bin\indy70_indy9.bpl
Bin\indy70.map para Bin\indy70_indy9.map
Bin\dclindy70.bpl para Bin\dclindy70_indy9.bpl
Bin\dclindy70.map para Bin\dclindy70_indy9.map
Lib\indy.dcp para Lib\indy_indy9.dcp
Lib\indy.dcu para Lib\indy_indy9.dcu
Lib\dclindy.dcp para Lib\dclindy_indy9.dcp
Lib\dclindy.dcu para Lib\dclindy_indy9.dcu
Source\Indy para Source\Indy_9

Remova também todos os dcu's existentes dentro das pastas Lib e Lib\Debug, que tenham o nome iniciado com "id", por exemplo, "IdBaseComponent.dcu".

Descompacte o arquivo que você baixou. Dentro há uma pasta Lib e um arquivo Fulld7.bat que compila e instala para você, mais preferi fazer a instalação manualmente, para isso, é preciso compilar e instalar os seguintes pacotes, na sequência que segue:

IndySystem70.dpk (in Lib\System) --> Apenas Compila
IndyCore70.dpk (in Lib\Core) --> Apenas Compila
IndyProtocols70.dpk (in Lib\Protocols) --> Apenas Compila
dclIndyCore70.dpk (in Lib\Core) --> Compila e Instala
dclIndyProtocols70.dpk (in Lib\Protocols) --> Compila e Instala

Agora só falta adicionar os novos arquivos ao LibraryPath do delphi:

C:\Indy10\Lib\System
C:\Indy10\Lib\Core
C:\Indy10\Lib\Protocols

Era isso, agora seu Delphi 7 pode usufruir das melhorias e correção de bugs adicionadas ao Indy 10.

Qualque dúvida ou problema durante a atualização deixe um comentário.

Primeiros passos com git

2012-08-06T17:59:00.000-07:00

Depois de uma pausa, retomarei o assunto sobre git. Hoje vou mostrar como criar um novo repositório e efetuar as operações básicas. Se você não sabe o que é git ou ainda não tem o git instalado, leia o post anterior: Instalando e Configurando git no windows

Para começar, abra o Git Bash no diretório onde você vai criar seu projeto, para efeitos de exemplo vou manter o projeto na raiz do drive C.

$ mkdir learning-git
$ cd learning-git
$ git init
  Initialized empty Git repository in c:/learning-git/.git/
$ touch README.md

O que fizemos até agora? Criamos um diretório "learning-git" e dentro dele criamos um novo repositório git. O command "touch" cria um arquivo em branco, é uma boa prática ter o arquivo README com as instruções básicas sobre o projeto. A extensão .md se refere a Markdown.

Antes de fazer o commit, vamos executar o seguinte commando para verificar as alterações.

$ git status
# On branch master
#                 
# Initial commit  
#                 
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#                                                                 
#       README.md                                                 
nothing added to commit but untracked files present (use "git add" to track)

Como podem ver ele reconheceu o arquivo README.md como não rastreado, isso quer dizer que o mesmo ainda não se encontra no repositório. Antes de efetuar o commit do arquivo é necessário adicionar o mesmo ao repositório;

$ git add .
$ git commit -a -m "Meu Primeiro Commit"
[master (root-commit) 6b97712] Meu Primeiro Commit
 1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 README.md

O primeiro comando irá adicionar todos os arquivos incluídos/removidos/modificados no próximo commit. Agora você precisa acessar o github e criar um novo repositório, conforme o exemplo abaixo. Lembre-se de utilizar como "Repository Name" o mesmo nome você usou na sua máquina local.

Feito isso, vamos executar os comandos abaixo.

$ git remote add origin https://github.com/fabriciocolombo/learning-git.git
$ git push -u origin master
Username:fabriciocolombo
Password:*******
Counting objects: 3, done.
Writing objects: 100% (3/3), 245 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/fabriciocolombo/learning-git.git
 * [new branch]      master -> master
Branch master set up to track remote branch master from origin.

O primeito commando vai associar o repositório local com o repositório remote. O segundo commando executa o "push", que vai subir os dados locais para o servidor remoto, para isso será solicitado o seu usuário e senha do github.

Eu recomendo fortemente a leitura de um artigo do Fábio Akita sobre a utilização do git, aliás, ele possue vários posts sobre o assunto, mais recomendo um em especial que mostra de forma bem didática como trabalhar com branches, fazer merge e outros recursos bacãnas. O post é Micro Tutorial de Git.

Abraços e até a próxima.

Instalando e Configurando git no windows

2012-05-19T11:20:00.002-07:00

Olá pessoal, hoje vou falar um pouco sobre git e github. Git é um sistema de controle de versão distribuído (DVCS) free e open source, para saber mais sobre o mesmo, acesse o site. Github é um serviço de hospedagem de código fonte que utiliza o git como sistema de controle de versão, possuí planos gratuítos e comerciais, e é amplamente utilizado pela comunidade open source. O Github pode se considerado como uma rede social, onde você pode ser seguido e seguir os projetos de outras pessoas, pode facilmente enviar contribuições à projetos open source, e também há empresas, pelo menos lá fora, que tem utilizado o github como forma de avaliar a contratação de programadores.

Nos sistemas de controle de versão distribuído, quando se faz um fork de um projeto, você obtêm uma cópia de todo o repositório do projeto, com todo o histórico de commits, e o seu projeto ainda vai continuar vinculado ao projeto original, sendo assim, se você implementar novas features ou correção de bugs, você pode enviar um pull request ao dono do projeto original, que pode incorporar sua solicitação de forma bastante simples.

Se você chegou até aqui é porque está interessado em conhecer melhor o git, e a melhor forma de aprender é fazendo, não é mesmo? Então antes de prosseguir com a leitura, accesse o site e baixe a versão do git compatível com seu sistema operacional. Enquanto faz o download aproveita e dá um pulinho no github e faça o seu cadastro.

A instalação do git é bastante simples, só modifiquei o diretório para instalar em "C:\Git"

Na tela de componentes deixei a configuração default.

Na tela de configuração "Path environment" também mantive a opção default "Use Git Bash only", que não adiciona o git ao path do windows, desse modo, sempre que for necessário acessar o git você pode precisa abrir o "Git Bash". É a opção mais conservadora. Leia as demais opções com atenção e sinta-se a vontade para utilizá-las.

E por último mais não menos importante, a configuração de quebra de linha. Como você deve saber, o ambiente windows utiliza CRLF como quebra de linha, e o ambiente unix utiliza apenas LF. Na opção default para windows, as quebras de linhas são convertidas automaticamente no checkout e commit, então, deixe marcada a opção "Checkout Windows-style, commit Unix-Style line endings".

Agora vamos configurar a chave SSH para conseguir fazer commits no github. Primeiro, abra o Git Bash (pode ser atráves da barra Quick Launch, Iniciar\Programas ou botão direito do mouse no windows explorer) e vá até o seu diretório home (representado pelo caracter til "~"). Vamos verificar a existência da pasta ".ssh".

$ cd ~

$ ls -lha | grep .ssh

  drwxr-xr-x 2 fabricio admin 0 May 18 01:44 .ssh
$ cd .ssh

Caso não exista, como no exemplo abaixo, você pode criar a mesma.

$ cd ~

$ ls -lha | grep .ssh



$ mkdir .ssh

$ ls -lha | grep .ssh

  drwxr-xr-x 2 fabricio admin 0 May 18 01:44 .ssh
$ cd .ssh

Feito isso, vamos gerar um par de chaves pública e privada. Essa chave é utilizada quando fazemos commit(push) no github para garantir a nossa autenticidade. Nesse passo será utilizado o e-mail informado na conta do github. Ao ser solicitado o nome do arquivo para armazenar a chave, basta pressionar Enter e será utilizado o nome default. Também será solicitado uma senha (passphrase) que deverá ser informada toda vez que efetuar commit no github, então, coloque uma que você não vá esquecer :D

$ ssh-keygen -t rsa -C "your_email@domain.com"
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/YourUser/.ssh/id_rsa):<press enter>
Enter passphrase (empty for no passphrase): <informe sua senha>
Enter same passphrase again: <informe a mesma senha novamente>
Your identification has been saved in /c/Users/YourUser/.ssh/id_rsa.
Your public key has been saved in /c/Users/YourUser/.ssh/id_rsa.pub.
The key fingerprint is:
<Uma chave hexadecimal> <seu e-mail>

Agora essa chave precisa ser cadastrada no github. Para isso acesse o github e efetue o login. Acesse a opção "Account Settings" > Clique em "SSH Keys" > Clique em "Add SSH key"

Abra o arquivo id_rsa.pub com um editor de texto ~~descente~~ como Notepad++, UltraEdit, EditPlus, etc, nem pense em usar o Notepad :D , o conteúdo do arquivo é a sua chave pública, copie todo o conteúdo sem adicionar novas quebras de linha ou espaços em branco e cole dentro do campo "Key" no github. Dê um título para identificar a máquina que você está registrando e clique em "Add key". Será solicitado a confirmação da sua senha e o processo está concluído.

Agora vamos verificar se tudo está funcionando. Volte ao Git Bash e execute o comando abaixo. Não se preocupe com a mensagem que vai aparecer, é esperado que isso ocorra, apenas digite "yes" e pressione "enter".

 $ ssh -T git@github.com
 The authenticity of host 'github.com (207.97.227.239)' can't be established.
 RSA key fingerprint is 16:27:ac:a5:76:28:2d:36:63:1b:56:4d:eb:df:a6:48.
 Are you sure you want to continue connecting (yes/no)? <yes> <enter>
 Warning: Permanently added 'githu.com,207.97.227.239' (RSA) to the list of known hosts.
 Connection closed by 207.97.227.239

Repita o commando anterior

 $ ssh -T git@github.com
 Enter passphrase for key '/c/Users/YourUser/.ssh/id_rsa': <informe sua senha>
 Hi ! You've successfully authenticated, but GitHub does not provide shell access.

Vamos também configurar o nome de usuário e e-mail que será utilizado para identificar seus commits.

 $ git config --global user.name "Nome Completo"
 $ git config --global user.email "your_email@domain.com"

Pronto, agora você já está pronto para utilizar o Git e Gitghub, no próximo post vou mostrar como criar um repositório e interagir com o repositório.

Edit:

Esqueci de mencionar a configuração para quem utiliza proxy.

 $ git config --global http.proxy http://proxyuser:proxypwd@proxy.server.com:3128

Consultando e eliminando sessões ativas no PostgreSQL

2012-03-20T17:06:00.000-07:00

Já mostrei como listar/matar as sessões ativas no oracle, hoje vou mostrar essa mesma funcionalidade acessando o banco de dados PostgreSQL. O sql a seguir lista todas as sessões ativas.

select datname, 
       procpid, 
       usename, 
       application_name, 
       client_addr, 
       client_hostname, 
       backend_start 
  from pg_stat_activity

EDIT:

A coluna procid foi renomeada para pid a partir da versão 9.2 do PostgreSQL

Com a lista de usuário em mãos, podemos optar por "matar" a sessão de algum usuário ativo, para isto basta executar o comando abaixo, substituindo o "procpid' pelo valor retornado da consulta anterior.

select pg_terminate_backend(procpid)

E para eliminar todas as conexões ativas, menos a conexão atual.

SELECT pg_terminate_backend(procpid) 
   FROM pg_stat_activity 
  WHERE procpid <> pg_backend_pid();

Consultando e eliminando sessões ativas no Oracle

2012-03-14T18:03:00.001-07:00

Hoje vou deixar uma dica rápida, como listar as sessões ativas no oracle, isto é, os usuários que estão conectados através de alguma aplicação cliente. O sql a seguir lista todas as sessões ativas excluindo os processos do próprio oracle.

SELECT s.username,
     s.osuser,
     s.sid,
     s.serial#,
     p.spid,
     s.status,
     s.machine,
     s.program,
     TO_CHAR(s.logon_Time,'DD-MON-YYYY HH24:MI:SS') AS logon_time
   FROM v$session s
  inner join v$process p
     on s.paddr = p.addr
  WHERE s.status = 'ACTIVE' 
    and s.type <> 'BACKGROUND'

Com a lista de usuário em mãos, podemos optar por "matar" a sessão de algum usuário ativo. Para isso basta executar o comando abaixo, substituindo o "sid" e "serial#' pelos valores retornados da consulta anterior.

ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE;

Por hoje era isso.

Delphi SqlBuilder

2012-02-16T16:22:00.000-08:00

Olá, há algum tempo eu havia desenvolvido uma rotina para modificar a cláusula Where de sql statements(pelo menos dos mais simples). Agora surgiu a oportunidade de compartilhar a solução, então aqui está.

Logo abaixo podemos ver a definição da classe.

TSqlBuilder = class
  private
  public
    class function AddWhere(ASql, AWhere: String; AMainTable: String = ''): String;
    class function ChangeOrdeBy(ASql, AOrderFields: String): String;
  class function RemoveOrderBy(ASql: String): String;
  end;

Como podem ver a definição da classe é bastante simples e possui apenas funções de classe, nada de parser's de sql complicados. O argumento "AWhere' já deve estar formatado ao chamar a função, dando mais liberdade ao desenvolvedor para manipular a claúsula Where da maneira mais conveniente, por exemplo:

var
  qry: TAlgumTipoDeQuery;
begin
  (...)
 qry.Sql.Text := 'Select * from TabelaA Where X = 1';
  
 //Native Types
 qry.Sql.Text := TSqlBuilder.AddWhere(qry.Sql.Text, ' Y = ''a''');
 qry.Open;
 
 //Bind Parameters
 qry.Sql.Text := TSqlBuilder.AddWhere(qry.Sql.Text, ' Y = :Y');
 qry.ParamByName('Y').AsString := 'a'
 qry.Open;
end;

O argumento adicional "AMainTable" que ainda não foi utilizado, é importante quando temos um sql que possui um subselect antes da claúsula from, por exemplo, veja o sql abaixo:

Select a, 
        (select b.b from Tabela2 b where b.x = 3) as b
    from Tabela1 a
   where a.x = 2

Por padrão a claúsula "Where" será adicionada ao primeiro "from' encontrado, no caso, adicionando imediatamente após "Tabela2". Para evitar que isso aconteça, devemos informar qual é a tabela principal do sql, passando como argumento para o método AddWhere o valor "Tabela1".

qry.Sql.Text := 'Select a, ' +
                  '       (select b.b from Tabela2 b where b.x = 3) as b ' +
                   '  from Tabela1 a ' +
                   ' where a.x = 2';
   qry.Sql.Text := TSqlBuilder.AddWhere(qry.Sql.Text, ' Y = :Y', 'Tabela1');

Também temos o método ChangeOrdeBy, que adiciona ou modifica a cláusula "Order by". O modo de usar o mesmo é como segue:

var
  qry: TAlgumTipoDeQuery;
begin
  (...)
 qry.Sql.Text := 'Select * from TabelaA';
 qry.Sql.Text := TSqlBuilder.ChangeOrdeBy(qry.Sql.Text, 'a');
 //Retorna "Select * from TabelaA order by a"
 
 qry.Sql.Text := 'Select * from TabelaA oder by a';
 qry.Sql.Text := TSqlBuilder.ChangeOrdeBy(qry.Sql.Text, 'b asc, c desc');
 //Retorna "Select * from TabelaA order by b asc, c desc"

E por último, o método RemoveOrderBy, que remove qualquer cláusula "Order by" que exista.

O código completo contendo os testes unitários está disponível aqui.

Qualquer sugestão, bug ou melhoria, façam um fork, modifiquem e façam um pull request que eu atualizo aqui, ou abra uma Issue no site do projeto, mais não deixe de me avisar. ;)

Abraços.

Criando um CustomAppender para JTextArea com Log4j

2012-02-15T18:58:00.001-08:00

Recentemente estavámos trabalhando em um projeto de migração de dados em Java, e foi criada uma pequena interface para interagir com o usuário utilizando Swing. Em dado momento, decidimos incluir um JTextArea para mostrar ao usuário as informações emitidas pelo log do programa, no caso, utilizando Log4j, para que o mesmo pudesse acompanhar com mais detalhes o que o conversor estava fazendo no momento.

Foi então que pesquisando um pouco no google vimos que há como criar nossos próprios Appender's do Log4j, e é sobre isso que eu vou falar hoje.

Para criar um novo appender vamos estender a classe abstrata AppenderSkeleton, que já provê todas as funcionalidades básicas para tratamento da mensagem. São obrigatórios a implementação de 3 métodos:

close(): Utilizado para liberar os recursos alocados pelo appender como arquivos, conexões de rede, etc.

requiresLayout(): Indica se o appender necessita de um layout configurado para funcionar. Em casos onde o appender pode trabalhar com ou sem layout, o método deve retornar true;

append(LoggingEvent event): É o método principal que devemos implementar, é onde residirá o nosso tratamento customizado do log. Ele recebe um argumento do tipo LoggingEvent, que tem várias atributos como o Level da mensagem, a mensagem, a causa do erro em caso de exceções, etc.

Ok, agora vamos ver um pouco de código. Crie um projeto Maven e adicione as seguintes dependencias:


 log4j
 log4j
 1.2.16



 commons-lang
 commons-lang
 2.6

Em seguida crie uma classe chamada TextAreaAppender e implemente os métodos necessários.

public class TextAreaAppender extends AppenderSkeleton {
 
 //Outro métodos foram omitidos para simplificar o exemplo

 @Override
 protected void append(LoggingEvent event) {
  //formata a mensagem de acordo com o layout 
  String formatted = getLayout().format(event);

  jTextArea.append(formatted);

  // Se a mensagem possuí informações sobre a exceção que causou o erro
  if (event.getThrowableInformation() != null) {
   jTextArea.append(ExceptionUtils.getFullStackTrace(event
     .getThrowableInformation().getThrowable()));
  }
 }
}

Agora vou criar uma aplicação para exemplificar a configuração do Appender

public class Main extends JFrame {

 public static void main(String[] args) {
  Main main = new Main();

  main.init();
 }

 private void init() {
 
  textLogArea = new JTextArea();
 
     //Criação dos demais componentes visuais
  
  //Instancia o nosso Appender
  TextAreaAppender appender = new TextAreaAppender(textLogArea);

  //Adiciona o appender ao logger
  Logger.getRootLogger().addAppender(appender);

  logger.info("Log inicializado");
 }
}

O projeto completo está disponível no meu github.

Serviços da Google Maps API de Geocodificação

2012-02-13T11:44:00.001-08:00

Olá, hoje vou mostrar um exemplo de como consumir o serviço do Google Maps API de geocodificação. A definição de geocodificação eu extraí do próprio site do google:

"Geocodificação é o processo de conversão de endereços (como "1600 Amphitheatre Parkway, Mountain View, CA") em coordenadas geográficas (como latitude 37.423021 e longitude -122.083739), que você pode usar para colocar marcadores ou posicionar o mapa. A Google Geocoding API fornece uma maneira direta de acessar um geocodificador por meio de uma solicitação HTTP. Além disso, o serviço permite que você realize a operação inversa (transformar coordenadas em endereços); esse processo é conhecido como "geocodificação reversa"."

Uma solitação de geocoding deve ter basicamente os seguinte formato:

http://maps.googleapis.com/maps/api/geocode/output?parameters

onde output significa o formato do retorno dos dados, que pode ser json(recomendável) ou xml.

Além disso são obrigatórios os parâmetros:

address — o endereço que você deseja geocodificar
ou
latlng — o valor textual de latitude/longitude para o qual você deseja obter o endereço mais próximo.

sensor — indica se a solicitação de geocodificação vem ou não de um dispositivo com sensor de localização. Esse valor deve ser true ou false.

A resposta da requisição contém dois elementos raiz:

status - contém metadados sobre a solicitação. Consulte os Códigos de status no site.

results - contém uma matriz de informações de endereços geocodificados e informações geométricas.

Eu implementei uma biblioteca bem simples que suporta os dois formatos de resposta: json e xml.

Para interpretar o resultando em json, utilizei a biblioteca lkjson, pois, já tinha utilizado a mesma em outros projetos e achei bastante simples de usar, mais existem outras opções como o SuperObject e Delphi Web Utils.

Para interpretar o formato xml optei por utilizar o Xml Data Binding do delphi, que através de um wizard cria classes tipadas a partir do arquivos xml, deixando todo o processo de transformação transparente.

Basicamente o que fiz foi o seguinte, efetuei uma requisição no serviço de geocodificação no formato xml e salvei os dados retornados em um arquivo xml. Em seguida, utilizei o Xml Data Binding para transformar esse xml em classes. Essas classes são o resultado final da solicitação, seja ela em json ou xml.

Quando a requisição é no formato xml, é utilizado o binding do XmlDocument:

class function TGoogleApiGeoXml.XmlToGeocodeResponse(const AXmlText: String): IGeocodeResponse;
var
  vXmlDocument: IXMLDocument;
begin
  vXmlDocument := TXMLDocument.Create(nil);
  vXmlDocument.LoadFromXml(UTF8Encode(AXmlText));

  Result := vXmlDocument.GetDocBinding('GeocodeResponse', TGeocodeResponse) as IGeocodeResponse;
end;

Quando a requisição é no formato json, escrevi o parser "na unha", que retorna o mesmo tipo de objeto da solicitação em xml, deixando a aplicação que consome o serviço utilizar o mesmo sem se importar se é xml ou json.

function TGoogleApiGeoJson.ConvertFromJson(const AJsonText: String): IGeocodeResponse;
var
  vJsonResponse: TlkJSONobject;
  vResults: TlkJSONbase;
begin
  Result := TGeocodeResponse.NewGeocodeResponse;

  vJsonResponse := TlkJSONobject(TlkJSON.ParseText(UTF8Encode(AJsonText)));
  try
    vResults := TlkJSONlist(TlkJSONlist(vJsonResponse.Field['results']).Field['address_components']).Items[0];

    ParseStatus(Result, vJsonResponse);
    ParseType(Result, vResults);
    ParseFormattedAddress(Result, vResults);
    ParseAddresses(Result, vResults);
    ParseGeometry(Result, vResults);
  finally
    vJsonResponse.Free;
  end;
end;

Na sistema em si, o único código que ele precisa executar é esse:

var
  vResponse: IGeocodeResponse;
begin
  vResponse := TGoogleApiGeocodeDownload.GetGeocode("http://maps.googleapis.com/maps/api/geocode/json_ou_xml?address=1600+Amphitheatre+Parkway,+Mountain+View,+CA&sensor=true_ou_false");
 
 //Lógica que utiliza a resposta da solicitação

O implementação do método GetGeocode é bastante simples também, ele faz uma requisição HTTP utilizando indy conforme abaixo

class function TGoogleApiGeocodeDownload.HttpGet(Url: String): String;
var
  lHTTP: TIdHTTP;
  lStream: TStringStream;
begin
  lHTTP := TIdHTTP.Create(nil);
  lStream := TStringStream.Create(EmptyStr);
  try
    lHTTP.Get(Url, lStream);
    
    lStream.Position := 0;

    Result := UTF8Decode(lStream.DataString);
  finally
    FreeAndNil(lHTTP);
    FreeAndNil(lStream);
  end;
end;

E de acordo com o formato dos dados faz uma chamada ao parser correspondente para retornar o objeto.

class function TGoogleApiGeocodeDownload.GetGeocode(AUrl: String): IGeocodeResponse;
var
  vDados: String;
  vFormato: TOutputFormat;
begin
  vFormato := DiscoverFormat(AUrl);

  vDados := HttpGet(AUrl);

  case vFormato  of
    Json: Result := TGoogleApiGeoJson.JsonToGeocodeResponse(vDados);
    Xml : Result := TGoogleApiGeoXml.XmlToGeocodeResponse(vDados);   
  end;
end;

Mais informações sobre limitações de uso e sobre os parâmetros utilizados na requisição HTTP podem ser encontrados aqui.

O código fonte completo com exemplo de como utilizar pode ser acessado aqui no meu bitbucket.

Um abraço e fique ligado nos próximos posts.

Simplificando o merge no TortoiseSVN com DiffMerge

2012-02-03T04:05:00.000-08:00

Muitos de vocês já devem ter se aborrecido com a ferramenta de diff(comparação entre arquivos) que vem junto com o TortoiseSVN. Ela não consegue resolver sozinha vários tipos de conflitos e a resolução manual é complicada.

Procurando uma ferramenta melhor tempos atrás, encontrei esse post do Erick Sasse onde ele recomendava a ferramenta DiffMerge que é gratuita e funciona no Windows, Mac OS X e Linux.

Um dos diferenciais do DiffMerge é o suporte a merge de 3 arquivos, ou seja, quando mais de um desenvolvedor altera um arquivo ele considera o arquivo base e as duas versões alteradas.

Para configurar ele é bastante simples. Acesse a tela de configuração do TortoiseSVN (Botão direito do mouse -> TortoiseSVN ->Settings) e modifique as configuraçães conforme o exemplo abaixo.

External Programs
    Diff Viewer
      - External
     C:\Program Files\SourceGear\DiffMerge\DiffMerge.exe /t1=%bname /t2=%yname %base %mine

External Programs
    Merge Tool
      - External 
        C:\Program Files\SourceGear\DiffMerge\DiffMerge.exe /m /r=%merged /t1=%yname /t2=%bname /t3=%tname /c=%mname %mine %base %theirs

Por hoje era isso, se alguém quiser sugerir outras ferramentas similares deixe um comentário.

Integração Contínua - Instalando as ferramentas(Java JRE, TomCat e Hudson)

2012-01-19T16:56:00.000-08:00

Já faz algum tempo desde o último post, o tempo está curto, mais dando continuidade a série sobre Integração Contínua, hoje vou mostrar como instalar e configurar as ferramentas que iremos utilizar: Java JRE, Tomcat, Hudson e VisualSVN Server.

Java
Como servidor de aplicação utilizarei o Tomcat e para isso, precisamos do Java Runtime Edition (JRE) (ou Java Development Kit(JDK) caso já tenha instalado). Você pode obter o instalador nesse link Java SE Downloads. Escolha a opção JRE. A instalação é no estilo next, next, finish.

Tomcat
Agora vamos intalar o Tomcat. Você pode obter a última versão através dessa página Tomcat 7 downloads. Escolha a opção 32-bit/64-bit Windows Service Installer. Durante a instalação, pequenas configurações devem ser feitas. Na etapa ilustrada abaixo, deve ser informado um usuário e senha de administração do tomcat e no próximo passo, deve ser informado o diretório onde está instalado o java.

Após concluir a instalação, acesse pelo browser a url http://localhost:8080 e você deve ver a página do Tomcat. Ao acessar a opção Tomcat Manager será solicitado a senha informada no momento da instalação, e você poderá controlar as aplicações instaladas no tomcat.

Hudson
Agora precisamos do Hudson. O Hudson é um servidor de integração contínua onde é possível criar projetos que podem ser construídos em vários passos. Acesse a página do hudson e faça o download da última versão estável no formato war. No momento dessa publicação a última versão disponível é a 2.2.

Após efetuado o download, copie o war para a pasta "webapps" dentro do diretório onde o Tomcat foi instalado e depois reinicie o serviço do Tomcat acessando o mesmo pelo painel de controle do windows. Acesse o endereço http://localhost:8080 e na opção Tomcat Manager, deve estar aparecendo a aplicação hudson com status rodando.

VisualSVN Server
Ainda falta o servidor SVN para gerenciar o código fonte. No caso vou utilizar o VisualSVN Server. Após a instalação vamos criar um usuário para acessar o repositório. Com o botão direito sobre a pasta Users vá na opção Create New User e informe um usuário e senha. Vamos repetir o processo para criar um repositório. Clique com o botão direito sobre a pasta Repositories, informe um nome. Logo após clique com o botão direito sobre o repositório recém criado e escolha a opção Novo\Project Structure e informe o nome do projeto. Isso já criará as pastas branch, tag e trunk.

Como client do SVN eu utilizarei o TortoiseSVN

No próximo post mostrarei como criar a tarefa no hudson que vai fazer update do código fonte diretamente do svn, compilar o projeto e enviar e-mail de notificação, tudo isso de forma automática a cada commit no svn.

Integração contínua - Compilar projeto delphi por linha de comando (dcc32) - Recursos Avançados

2011-12-05T15:18:00.000-08:00

Olá pessoal. No último post falamos sobre compilar projeto delphi por linha de comando, continuando o assunto, hoje vamos ver como compilar o projeto habilitando opções mais específica de compilação para rodar o projeto em modo de depuração. Nosso projeto de teste utiliza duas bibliotecas externas: FastMM e DUnit, para que o FastMM(em FullDebugMode) consiga captar corretamente o nome das units e métodos onde ocorreram os leaks de memória, é necessário modificar algumas configurações no projeto. Outras ferramentas como o Delphi Code Coverage, utilizam o Map File do executável para analizar a cobertura de código, então também habilitamos a geração do mesmo.

A configuração do projeto nessa caso deveria ficar assim:

Um dos nossos objetivos é automatizar o processo de build sem tem que ficar abrindo a IDE para reconfigurar o projeto, então, a IDE fica configurada no modo de release, digamos assim, e durante o build automatizado nos habilitamos o que for necessário de forma automática.

Só para refrescar a memória, a última compilação que fizemos foi a seguinte:
* -Q: Quiet Compile
* -W-: Warnings off
* -H-: Hints Off

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H-
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

Agora vamos configurar o compilador conforme as opções destacadas nas imagens acima, na sequência em que elas aparecem. Primeiro o Optimization, que é identificado pela diretiva de compilação $O. As diretivas de compilação são ativadas/desativadas com a seguinte sintaxe -$LetraDaDiretiva seguidos de -(desativar) ou +(ativar). Agora podemos concluir que para desativar a diretiva Optimization, devemos incluir o parâmetro -$O-, e assim o faremos.

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H- -$O-
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.14 seconds, 314372 bytes code, 7433 bytes data.
>Build Automatizado\ExemploDCC32>

Se prestarem atenção na saída do console, houve um ligeiro aumento no tamanho do código de 314356 bytes code para 314372 bytes code provando que nossa alteração surtiu efeito.

Seguindo as opções que modificamos, devemos habilitar a opção Stack Frames, que força o compilador a gerar o stack frames para todas as procedures e funções. Esse item também é um diretiva de compilação identificada pela letra W, portanto, devemos acrescentar o parâmetro -$W+. O código desse projeto é muito pequeno para essa alteração causa impacto no tamanho, mais podemos ver que o projeto compilou com sucesso.

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H- -$O- -$W+
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.14 seconds, 314372 bytes code, 7433 bytes data.
>ExemploDCC32>

Já modificamos as duas opções da aba Compiler, agora vamos para a aba Linker, onde temo como primeira opção selecionada a geração do Map file. Há três opções do mesmo:
* Segments: Parâmetro -GS
* Publics: Parâmetro -GP
* Detailed: Parâmetro -GD

A saída do console não é modificada, mais podemos solicitar a listagem do arquivo .map para confirmar sua geração. Observe.

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H- -$O- -$W+ -GD
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.19 seconds, 314372 bytes code, 7433 bytes data.

>ExemploDCC32>dir *.map
 O volume na unidade D não tem nome.
 O número de série do volume é 745C-EA2C

 Pasta ExemploDCC32

15/08/2011  21:18           302.428 ExemploDCC32.map
               1 arquivo(s)        302.428 bytes
               0 pasta(s)  8.627.687.424 bytes disponíveis

>ExemploDCC32>

E por último, vamos habilitar a opção Include TD32 debug info, que faz com que o compilador incluar informações adicionais de debug dentro do executável, tornando o tamanho do executável muito maior. O parâmetro utilizado nesse caso é o -V (Debug Information in EXE) e o executável aqui passou de 365kb para 2.790kb.

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H- -$O- -$W+ -GD -V
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.30 seconds, 314372 bytes code, 7433 bytes data.

>ExemploDCC32>

Note como o tamanho do código não aumentou, apenas o tamanho do executável, e isso também não afeta a performance da aplicação, mas lembrando que os parâmetros apresentados neste post são para usar em modo de desenvolvimento.

Integração contínua - Compilar projeto delphi por linha de comando (dcc32)

2011-11-12T07:58:00.000-08:00

Olá pessoal, tudo bem? Nessa série de posts sobre Integração Contínua, precisamos compilar nosso projeto de forma automatizada, para conseguir rodas os testes sempre com a última versão disponível do código fonte, e é sobre isso que vou falar hoje.

A partir do delphi 2007 há integração com msbuild, o que facilita muito a nossa vida, sem falar que no Delphi XE uma das ferramentas incluídas no pacote é o Final Builder, excelente ferramente de build automatizado. Infelizmente, muita gente ainda utiliza o delphi 7 (eu sou um deles) e nesse caso o trabalho é mais braçal. Esse post tem como foco aqueles que por algum motivo ainda utilizam - principalmente - o delphi 7.

Para compilar os projetos, é utilizado o dcc32.exe, que é o compilador que vem junto com o delphi e que o mesmo usa para compilar nossos projetos. Ele fica localizado na pasta $(Delphi)\bin. Se digitar dcc32 no prompt de comando, será listado os parâmetros existentes para o mesmo. Caso haja mais de uma versão do delphi instalado, é recomendado utilizar o caminho absoluto do compilador para garantir que está utilizando a versão correta.

Primeiro, vamos falar dos parâmetros mais importantes.

-B: Indica que serão compiladas todas as units do projeto, ou seja, é equivalente ao Build da IDE.

-Q: Executa uma compilação silenciosa. A compilação normal lista todas as units que estão sendo compiladas, na compilação silenciosa, apenas Hints, Warnings e erros serão exibidos.

-H: Habilita (-H+) ou desabilita (-H-) a exibição de hints.

-W: Habilita (-W+) ou desabilita (-W-) a exibição dos Warnings emitidos pelo compilador. Para habilitar ou desabilitar um warning específico, é preciso especificá-lo após o parâmetro, precedidos de + ou -. Exemplo: -W-SYMBOL_PLATFORM+UNIT_DEPRECATED

-R: Conjunto de diretórios onde o compilador irá buscar por arquivos de resources (.RC, .RES) utilizados no projeto;

-U: Conjunto de diretórios onde o compilador irá procurar os arquivos .PAS ou .DCU utilizados no projeto. Isso inclui os arquivos do projeto e as biblietecas externas.

Os diretórios passados no parâmetro devem ser estar separados por ponto e vírgula (;) e entre aspas duplas - para cada diretório - caso haja espaço em branco em alguma parte do caminho

Isso já é suficiente para compilar a maior parte dos projetos, então vamos por esse conhecimento em prática.

Primeiro, vamos criar um novo projeto que terá apenas fim didático para conhecer melhor os recursos do compilador. No form principal adicione um botão e dê a ele o nome de btnFacaAlgo e no evento OnClick insira o código abaixo:

procedure TFrm_Main.btnFacaAlgoClick(Sender: TObject);
var
  i: Integer;
  k: Integer; //Hint - variable never used
begin
  if (DebugHook <> 0) then; //Warning - Symbol specific to a platform

  while i < 10 do //Warning - variable not initialized
  begin
    Inc(i);
  end;
end;

Esse código produz dois Warnings e um Hint, e não faz absolutamente nada além disso. Salve o form principal como uMain.pas e o projeto como ExemploDcc32.dpr. Agora já podemos brincar com o compilador. Abra o prompt de comando e digite dcc32. Você deve ver uma saída como essa:

Pelo prompt, navegue até o diretório do projeto para não precisar digitar o caminho absoluto do projeto. Feito isso, vamos a nosso primeira tentativa de compilação:

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
uMain.pas(29) Warning: Symbol 'DebugHook' is specific to a platform
uMain.pas(31) Warning: Variable 'i' might not have been initialized
uMain.pas(27) Hint: Variable 'k' is declared but never used in 'TFrm_Main.btnFacaAlgoClick'
uMain.pas(38)
ExemploDCC32.dpr(16)
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

Como podem ver, foram listados dois warnings, um hint e os arquivos contidos no projeto, no caso, uMain e ExemploDCC32.dpr. É fácil imaginar que uma saída de console assim ficaria um tanto quanto poluída quando lidamos com um projeto grande, então, vamos dar uma enxugada nisso. Primeiro, vamos deixar de fora a listagem das units incluídas no projeto, pois não será relevante para o nosso caso, e para isso, vou incluir a diretiva -Q (Quiet Compile) na linha de comando.

>\ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
uMain.pas(29) Warning: Symbol 'DebugHook' is specific to a platform
uMain.pas(31) Warning: Variable 'i' might not have been initialized
uMain.pas(27) Hint: Variable 'k' is declared but never used in 'TFrm_Main.btnFacaAlgoClick'
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

Já melhorou, mais ainda há muita informação, por exemplo, o alerta de que DebugHook é específico para uma plataforma não é relevante na maioria dos casos, pois a aplicações delphi em geral só rodam no windows de forma nativa(há opções como o Kylix e o Delphi XE2 que compila para iOS), então podemos tranquilamente desativar esse warning. Para isso, incluirei o parâmetro -W-DiretivaQueVouDesabilitar, no caso, "-W-Symbol_Platform".

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W-Symbol_Platform
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
uMain.pas(31) Warning: Variable 'i' might not have been initialized
uMain.pas(27) Hint: Variable 'k' is declared but never used in 'TFrm_Main.btnFacaAlgoClick'
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

Para desativar todos os warnings, bastaria o parâmetro "-W-".

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W-
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
uMain.pas(27) Hint: Variable 'k' is declared but never used in 'TFrm_Main.btnFacaAlgoClick'
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

Agora só restou o Hint, e também vamos desativar ela pois não vão agregar valor para o nosso objetivo. Como dito anteriormente, basta incluir o parâmetro "-H-", e veja-mos o resultado final.

>ExemploDCC32>dcc32.exe -b ExemploDCC32.dpr -Q -W- -H-
Borland Delphi Version 15.0
Copyright (c) 1983,2002 Borland Software Corporation
56 lines, 0.14 seconds, 314356 bytes code, 7433 bytes data.
>ExemploDCC32>

No próximo post, vamos fazer isso com um projeto que utiliza bibliotecas externas e explorar recursos mais avançados do compilador.

Até a próxima.

Integração contínua com Hudon, subversion e Delphi

2011-11-05T08:09:00.000-07:00

Cada vez mais estamos buscando maneiras de melhorar a qualidade do software que produzimos, gerando um código com menos bugs e um produto final que gere valor para o cliente. Uma das melhores maneiras para se desenvolver software é praticar TDD, não só por escrever o teste primeiro, mais por contribuir significativamente para a melhoria do design do código, com classes mais coesas e com poucas responsabilidades, consequentemente, temos classes mais fáceis de testar e menos suscetíveis a falhas, e ainda por cima ganhamos uma especificação testável de brinde. :P

Estes testes tem também um papel fundamental garantindo que não haja regressão do software, ou seja, quando alguém altera o código, os testes devem continuar passando, garantindo que tudo continua funcionando adequadamente. Então antes de cada commit, precisamos fazer update no svn para atualizar nossa working copy, rodar os testes e deixar tudo verdinho e só depois integrar nossas alterações. Mais há algo errado com essa sequência de passos. É muito manual. Depende do desenvolvedor. Há muitos pontos de falha, ele pode esquecer de sincronizar seu repositório local, pode esquecer de rodar os testes, pode estar trabalhando até tarde e estar cansado demais pra rodar os teste, etc, etc. E o que devemos fazer então? Automatizar, é claro.

Vou mostrar em uma série de posts como construir um ambiente para aplicar na prática Integração Contínua. Claro que integração contínua não é apenas sobre ferramentas, é também uma mudança de comportamento, tem que ser incorporado à cultura do time, mais uma coisa de cada vez. Vamos ver a definição dada por Martin Fowler:
"Integração contínua é uma prática de desenvolvimento de software onde os membros de uma equipe integram seu trabalho frequentemente, geralmente cada um integra no mínimo diariamente – levando a múltiplas integrações por dia. Cada integração é verificada por um build automático (incluindo testes) para detectar erros de integração tão rápido quanto possível. Muitas equipes descobrem que esta prática leva a problemas de integração significativamente reduzidos e permite que a equipe desenvolva software coeso mais rapidamente."

Para colocar isso em prática utilizare-mos o Hudson como servidor de integração, Visual SVN Server como sistema de controle de código fonte, DUnit para testes unitários e delphi-code-coverage para cobertura de código.

Fique atento às próximas publicações.

LiveBindings no delphi XE2

2011-09-09T09:12:00.000-07:00

Hoje vamos falar sobre LiveBindings, um dos novos recursos do Delphi XE2.

LiveBindings é um mecanismo de data-binding suportados pela VCL e FireMonkey. Ele é baseado em expressões (binding expressions), o que significa que usa expressões para ligar objetos uns aos outros, por meio de suas propriedades.

É importante salientar que o LiveBinding foi criado devido a inclusão do FireMonkey, uma vez que o mesmo não possui componentes DB-Aware. Ao invés da criação desses componentes optou-se por criar um mecanismo de data-binding, e foi uma decisão muito feliz. No caso do FireMonkey os componentes podem ser ligados ao DataSource de maneira relativamente simples e de forma visual.

Minha maior expectativa era pode utilizar esse recursos para ligar objetos de negócio a componentes visuais não data aware, deixando a manipulação dos dados mais transparente, sem precisar ficar alimentando manualmente os componentes visuais e depois recuperar esse valores também manualmente, e confesso que fiquei decepcionado com as opções oferecidas nesse sentido. É possível, mais é muito mais verboso e intrusivo do que eu gostaria que fosse.

No site da embarcadero há três tutoriais: Tutorial: Using LiveBinding Programatically, Tutorial: Using LiveBinding in VCL Applications e Tutorial: Using LiveBinding to Create a FireMonkey Application Without Code.

De maneira resumida, quando às ligações envolvem apenas componentes visuais, ela é feita através do object inspector. Os componentes visuais possuem uma propriedade chamada LiveBindings, onde você deve clicar e selecionar a opção New LiveBinding.... Isso criará um BindExpression, onde você deve configurar:
- ControlExpression: Propriedade do componente selecionado que deverá ser atualizada.
- SourceComponent: Componente de origem. Quando ele for modificado o componente atual será notificado.
- SourceExpression: Propriedade que será lida para atualizar a propriedade ControlExpression do componente atual.

Esse TBindExpression fica armazenado em um componente TBindingsList, que é adicionado ao form automaticamente.

Relativamente simples. Só tem um porém, dessa forma ainda não funcionará, porque não foi incluído recurso de auto notificação, ou seja, a VCL não gerencia os objetos envolvidos para fazer a notificação automaticamente quando o valor da propriedade do SourceComponent for modificada. Temos que fazer isso manualmente.Em cada objeto envolvido você tem que implementar o método OnChange e invocar BindingsList.Notify(ObjetoAlterado, 'PropriedadeAlterada'), para que as alterações sejam propagadas para os "ouvintes" do objeto.

Agora vamos ver como fazer o binding programaticamente, utilizando objetos não visuais. Dado uma classe TMyObject, vamos fazer o binding da classe com um TEdit adicionado em um form.

type
  TMyObject = class(TObject)
  private
    FStringValue: String;
    procedure SetStringValue(const Value: String);
  public
    property StringValue: String read FStringValue write SetStringValue;
  end;

Para declarar o binding precisamos da unit System.Bindings.Helper, e código fica assim:

TBindings.CreateManagedBinding(
        { inputs }
        [TBindings.CreateAssociationScope([Associate(FMyObject, 'MyObject')])],
        'MyObject.StringValue',
        { outputs }
        [TBindings.CreateAssociationScope([Associate(Edit1, 'edit1')])],
        'edit1.text',
        nil);

Feito isso, quando alterar o valor da propriedade StringValue do objeto MyObject, o valor do edit1.text será alterado automaticamente, certo? Errado! Assim como o caso anterior, a notificação também não é automática. Quando o valor da propriedade for alterado, também devemos notificar o gerenciador.

procedure TMyObject.SetStringValue(const Value: String);
begin
  if (FStringValue <> Value) then
  begin
    FStringValue := Value;
    TBindings.Notify(FMyObject, 'StringValue');
  end;
end;

O último detalhe é que os gerenciadores de bindings nos dois casos apresentados não são os mesmos. O TBindingsList gerencia uma lista de TBindExpression, enquanto, o
TBindings gerencia uma lista de TBindingExpression. Desse modo, se por algum motivo um componentes está associado aos dois tipos de binding, os dois gerenciadores devem ser notificados.

Eu sinceramente esperava mais do que isso. Acredito ainda não ser possível utilizar isso em produção - utilizando VCL -, mais não posso negar que já é um avanço. Espero que na próxima versão esse recurso evolua e torne esse trabalho mais simples e transparente, com notificação automática e um gerenciador único para controlar o binding.

Até a próxima.

PodCasts

2011-08-22T16:43:00.000-07:00

Olá pessoal. Gostaria de compartilhar com vocês os podcasts que acompanho e que ajudam muito a me manter atualizado sobre vários assuntos.

Grok podcast é o que tem assuntos mais variados, já "grokamos" sobre Ruby, Python, Arduíno, Node-JS e mais recentemente Erlang, e outros assuntos como Sistemas de controle de versão, carreira, desenvolvimento de games, e muito mais. Visite o site para saber o que significa o termo grok.

Improvecasts que foi produzido pelo Vinícius Teles durante o ano de 2007. Apesar da longa data ele trazem um conteúdo muito rico sobre desenvolvimento ágil.
AgilCast que é mantido pela AgilCoop, Cooperativa de Desenvolvimento Ágil de Software, e é composta por professores, alunos e ex-alunos do IME/USP. Seu conteúdo visa promover o uso de métodos ágeis de desenvolvimento de software.
Bluesoft podcast. No blog da bluesoft além dos podcasts tem muitos vídeos dos mais diversos assunto. Vale a pena conferir.
.Net Architects Podcast, como o próprio nome diz, tem foco na arquitetura do software, e traz discussões excelentes como: Princípios S.O.L.I.D, Arquitetura emergente e muitos outros.
TPodCast é infelizmente, o único podcast sobre delphi que conheço (pelo menos em português). Méritos para Erick Sasse e Leonel Togniolli
VoidPodcast, Um bate papo descontraído e bem humorado entre três amigos: Leandro Daniel (@leandronet), Vinícius Quaiato (@vquaiato, vulgo arrobinha) e Elemar Júnior (@elemarjr)
WoompaCast é uma start-up que recentemente começou a gravar podcasts compartilhando suas experiência.
Sembugs, é produzido por Elias Nogueira e é voltado para teste e qualidade de software.
DatabaseCast com foco principal em banco de dados.

Se alguém conhecer algum podcast que não esteja na lista, deixe um comentário com o link que eu vou incrementando aqui.

Abraços e até a próxima.

Google Developer Day Brasil 2011 - Prova de Programação

2011-08-13T07:18:00.000-07:00

Olá pessoal. Após ler o post do Erick Sasse entitulado Prova do Google Developer Day em Delphi decidi aceitar o desafio e resolver a prova (também em delphi) mesmo que eu não vá ao Google Developer Day 2011 Brasil.

A prova é bem interessante, é dado um texto em um alfabeto diferente do nosso e algumas regras para extrair do texto as quantidades de preposições e verbos, ordenar o texto e transformar as palavras em números base 20.

Uma explicação mais detalhada dos problemas pode ser encontrado no post do Erick mencionado anteriormente (Prova do Google Developer Day em Delphi).

Para fazer a prova, o link é este Provinha de Programação - Google Developer Day Brasil 2011, e você pode fazer mesmo que não queira participar do evento.

A minha implementação está disponível no meu bitbucket. Recomendo que façam, pois é um exercício bem interessante e a prova é diferente para cada um. Sugiro também que tentem resolver os problemas sem olhar nossas soluções, "Quem sabe você não tem idéias muito melhores?"

Strategy - Separando os comportamentos - Parte Final

2011-08-06T11:35:00.000-07:00

No último artigo falei sobre o padrão de projeto Strategy e expus um diagrama de como utilizar o strategy para exportação de dados. Hoje vou mostrar como podemos implementar o padrão seguindo a modelagem do diagrama.

Primeiro, vamos a declaração da interface que define a API de exportação e o enumerator com os formatos de saída suportados.

type
  TExporterType = (etText, etCSV, etXML);

  IExporterStrategy = interface
  ['{AA69E6F1-389F-4DC3-AC14-7FA7A749B183}']
    function GetFileName: String;
    procedure SetFileName(const Value: String);

    property FileName: String read GetFileName write SetFileName;

    procedure ExportToFile(const Value: String);
  end;

Agora vamos a implementação da classe responsável pela exportação em arquivo texto.

type
  TTextExporterStrategy = class(TInterfacedObject, IExporterStrategy)
  private
    FFileName: String;
  public
    procedure ExportToFile(const Value: String);
    
    function GetFileName: String;
    procedure SetFileName(const Value: String);
  end;
  
implementation
  
  /* Getter e Setter omitidos*/
  
procedure TTextExporterStrategy.ExportToFile(const Value: String);
var
  vFile: TextFile;
begin
  if (FFileName = EmptyStr) then
    raise EFileIsNotDefined.Create;

  AssignFile(vFile, FFileName);
  try
    Rewrite(vFile);

    WriteLn(vFile, Value);
  finally
    CloseFile(vFile);
  end;
end;

Também implementei a exportação em formato CSV. Assumi que os espaços em branco seriam substituídos pelo separador.

type
  TCSVExporterStrategy = class(TInterfacedObject, IExporterStrategy)
  private
    FFileName: String;
  public
    procedure ExportToFile(const Value: String);
    
    function GetFileName: String;
    procedure SetFileName(const Value: String);
  end;
  
implementation
  
  /* Getter e Setter omitidos*/  
  
implementation

{ TCSVExporterStrategy }

procedure TCSVExporterStrategy.ExportToFile(const Value: String);
var
  vFile: TextFile;
  vCSVLine: TStringList;
  i: Integer;
begin
  if (FFileName = EmptyStr) then
    raise EFileIsNotDefined.Create;

  AssignFile(vFile, FFileName);
  try
    Rewrite(vFile);

    vCSVLine := TStringList.Create;
    try
      ExtractStrings([' '], [' '], PChar(Value), vCSVLine);

      for i := 0 to vCSVLine.Count-1 do
      begin
        if i = vCSVLine.Count-1 then
         WriteLn(vFile, vCSVLine[i])
        else
         Write(vFile, vCSVLine[i] + ';');
      end;
    finally
      vCSVLine.Free;
    end;
  finally
    CloseFile(vFile);
  end;
end;

Agora que já temos duas classes concretas que implementam a exportação, vamos criar a factory responsável por instanciar as classes adequadas.

TExporterFactoryStrategy = class
  private
  public
    class function NewExporter(const ExporterType: TExporterType): IExporterStrategy;
  end;
  
implementation

{ TExporterFactoryStrategy }
class function TExporterFactoryStrategy.NewExporter(const ExporterType: TExporterType): IExporterStrategy;
begin
  case ExporterType of
    etText: Result := TTextExporterStrategy.Create;
    etCSV : Result := TCSVExporterStrategy.Create;
  else
    raise EStrategyNotImplemented.Create(ExporterType);
  end;
end;  

{ EStrategyNotImplemented }
constructor EStrategyNotImplemented.Create(AExporterType: TExporterType);
begin
  inherited CreateFmt('Strategy não implementado para o tipo "%s"',[GetEnumName(TypeInfo(TExporterType), Ord(AExporterType))]);
end;

Caso alguém peça a factory para instanciar um objecto para exportar para XML, uma exceção do tipo EStrategyNotImplemented será lançada.

Finalmente, vamos a classe TExporterContext, que representa a classe de negócio que faria a exportação dos dados na vida real, onde teria suas queries, cálculos e etc. O mais legal é que essa classe tem um nível de acoplamento extremamente baixo com o método de exportação, ela depende apenas da interface.

type
  TExporterContext = class
  private
    FExporterStrategy: IExporterStrategy;
  public
    constructor Create(const AExporterStrategyStrategy: IExporterStrategy);

    procedure MakeExport(const AOutputFile: String);
  end;

implementation

{ TExporterContext }

constructor TExporterContext.Create(const AExporterStrategyStrategy: IExporterStrategy);
begin
  FExporterStrategy := AExporterStrategyStrategy;
end;

procedure TExporterContext.MakeExport(const AOutputFile: String);
begin
  FExporterStrategy.FileName := AOutputFile;

  FExporterStrategy.ExportToFile(ClassName);
end;

E não poderiam faltar os Testes, como sempre, utilizando o DUnit. Se você ainda não é familiarizado com testes unitários, leia os posts: Usando DUnit para implementar testes unitários e Usando DUnit para implementar testes unitários - 2

type
  TTestTextExporter = class(TTestCase)
  private
  published
    procedure DeveLancarExcecaoQuandoFileNameNaoForDefinido;
    procedure DeveExportarParaArquivoNoFormatoTexto;
  end;

implementation

{ TTestTextExporter }

procedure TTestTextExporter.DeveExportarParaArquivoNoFormatoTexto;
var
  vTextExporter: IExporterStrategy;
  vValue,
  vFileName,
  vLine: String;
  vTextFile: TextFile;
begin
  vFileName := ExtractFilePath(ParamStr(0)) + 'textexporter.txt';

  vValue := 'Valor exportado';

  vTextExporter := TTextExporterStrategy.Create;
  vTextExporter.FileName := vFileName;
  vTextExporter.ExportToFile(vValue);

  CheckTrue(FileExists(vFileName), 'Arquivo não foi gerado.');
  
  AssignFile(vTextFile, vFileName);
  try
    Reset(vTextFile);

    Readln(vTextFile, vLine);

    CheckEqualsString(vValue, vLine);
  finally
    CloseFile(vTextFile);
  end;

  DeleteFile(vFileName);
end;

procedure TTestTextExporter.DeveLancarExcecaoQuandoFileNameNaoForDefinido;
begin
  ExpectedException := EFileIsNotDefined;
  TTextExporterStrategy.Create.ExportToFile('');
end;

initialization
  RegisterTest('Text Exporter',  TTestTextExporter.Suite);

Agora vou fazer um teste unitário e de integração na classe de contexto (TExporterContext). O teste de integração é o primeiro - método ExportaComoTexto - onde a classe de contexto recebe uma instância para o formato etText através da factory. TExporterFactoryStrategy.

TTextExporterContext = class(TTestCase)
  private
  published
    procedure ExportaComoTexto;
    procedure DeveInvocarOStrategy;
  end;

implementation

{ TTextExporterContext }

procedure TTextExporterContext.ExportaComoTexto;
var
  vExporter: TExporterContext;
  vFileName,
  vLine: String;
  vTextFile: TextFile;
begin
  vFileName := ExtractFilePath(ParamStr(0)) + 'textexporter.txt';

  vExporter := TExporterContext.Create(TExporterFactoryStrategy.NewExporter(etText));
  vExporter.MakeExport(vFileName);

  CheckTrue(FileExists(vFileName), 'Arquivo não foi gerado.');
  
  AssignFile(vTextFile, vFileName);
  try
    Reset(vTextFile);

    Readln(vTextFile, vLine);

    CheckEqualsString(vExporter.ClassName, vLine);
  finally
    CloseFile(vTextFile);
  end;

  DeleteFile(vFileName);
end;

Esse teste é necessário para ver o funcionamento como um todo, mais tem um ponto a mais de falha, que é a classe de exportação, pois, a mesma pode gerar erros - de I/O, por exemplo - que não indicam necessariamente que a classe de contexto está com problemas,portanto, para testar a classe de forma realmente unitária, precisamos ter controle sobre a estratégia de exportação,e para isso, utilizamos Mock Objects. Para delphi, temos as opções: Pascal Mock, Simple Mock e Ultra Basic MockObjects. Se alguém conhece mais algum, deixe um comentário. Eu optei por utilizar o Pascal Mock.

Não vou entrar em detalhes sobre Mocks nesse artigo, isso fica para uma próxima, mais segue abaixo como ficou a classe Mock e o teste.

type
  TMockExporterStrategy = class(TMock, IExporterStrategy)
  public
    procedure ExportToFile(const Value: String);
    function GetFileName: String;
    procedure SetFileName(const Value: String);
  end; 
  
implementation
{ TMockExporterStrategy }

procedure TMockExporterStrategy.ExportToFile(const Value: String);
begin 
  //Registra que o método foi chamado e com qual valor para o parâmetro
  AddCall('ExportToFile').WithParams([Value]);
end;

function TMockExporterStrategy.GetFileName: String;
begin
  //Não é utilizado no teste
  Result := EmptyStr;
end;

procedure TMockExporterStrategy.SetFileName(const Value: String);
begin
  //Registra que o método foi chamado e com qual valor para o parâmetro
  AddCall('SetFileName').WithParams([Value]);
end;
  
procedure TTextExporterContext.DeveInvocarOStrategy;
const
  FileName = 'C:\Exporter\filename.txt';
var
  vMock: TMockExporterStrategy;
  vContext: TExporterContext;
begin
  //Instância o Mock
  vMock := TMockExporterStrategy.Create;
  try
    //Indica que deve ser invocado o método SetFileName uma vez com o valor FileName definido na constante.
    vMock.Expects('SetFileName', 1).WithParams([FileName]);
 //Indica que deve ser invocado o método ExportToFile uma vez.
    vMock.Expects('ExportToFile', 1);

 //Instancia a classe de contexto passando o Mock como argumento.
    vContext := TExporterContext.Create(vMock);
    try
      vContext.MakeExport(FileName);
    finally
      vContext.Free;
    end;

 //O mock verifica se os métodos configurados como esperados foram realmente invocados e com a quantidade esperada.
    vMock.Verify('Não invocou o método "SetFileName"');
  finally
    vMock.Free;
  end;
end;

Com isso encerramos a séria sobre Strategy. Como de costume, o código fonte desse artigo e dos anteriores está disponível na minha conta do bitbucket.

Strategy - Separando os comportamentos - Parte 1

2011-08-04T19:08:00.000-07:00

O padrão de projeto Strategy define uma família de algoritmos, encapsula cada um e os torna intercambiáveis, traduzindo, definimos uma interface, criamos várias implementações para essa interface, e podemos mudar o comportamento do objeto trocando a implementação utilizada. Podemos inclusive fazer isso em runtime.

Vamos observar o diagrama abaixo.

A interface IExporterStrategy define o comportamento da estratégia, no caso, uma propriedade FileName que define o nome do arquivo de destino e um método ExportToFile que executa a exportação em si. No diagrama está definido três implementações para o estrategy: Text, XML e CSV, e uma classe TExporterContext que representa o contexto da aplicação no qual a rotina de exportação está inserida.

É importante ressaltar o relacionamento entre a classe TExporterContext e o Strategy. A classe depende apenas da interface, desconhecendo qualquer implementação. Isso é um bom indicador para o nosso design, pois, estamos programando para uma interface, não para uma implementação (Interface no sentido de abstração).

Note também a classe TExporterStrategyFactory. Ela é uma Simple Factory, uma classe comum com um método de classe que retornará uma instância para a classe de contexto. Quando fazemos isso, estamos invertendo o controle dos objetos, o contexto não tem controle sobre qual implementação será retornada pela Factory. Qualquer mudança no que diz respeito a instanciação, faremos apenas na Factory, por exemplo, queremos substituir o framework de manipulação de xml, então, criamos mais uma implementação do Strategy e modificamos a factory para retornar essa implementação.

A nomenclatura das classes também é importante, pois, um dos objetivos dos patterns é criar uma linguagem comum, de modo que a comunicação seja facilitada. E de fato olhando para o diagrama há uma rápida identificação dos padrões adotados para resolver o problema.

No próximo post vou mostrar como fica a implementação dessas classes em delphi.

Até a próxima.

Singleton em Delphi utilzando interfaces

2011-08-03T18:48:00.000-07:00

Olá, dando sequencia ao post anterior sobre Singleton, hoje irei mostrar uma implementação alternativa, e ao meu ver, mais elegante.

Nessa abordagem, o estado e/ou comportamento exposto pelo singleton deve ser declarado em uma interface.

type
  ISingleton = interface
  ['{F5B00272-536A-4C30-AB19-54496B106C7C}']
    procedure FacaAlgo;
  end;

Após a interface, vamos criar uma classe que seja responsável por implementá-la. O detalhe importante é que a classe fique abaixo da seção implementation, isso garante que ninguém fora dessa unit terá acesso a classe, tornado impossível criar uma nova instância da mesma.

implementation

type
  TSingletonInterface = class(TInterfacedObject, ISingleton)
  public
    procedure FacaAlgo;
  end;

{ TSingletonInterface }

procedure TSingletonInterface.FacaAlgo;
begin
  if IsConsole then
    Writeln(ClassName, ' Fazendo algo')
  else
    ShowMessageFmt('%s Fazendo algo', [ClassName]);
end;

Agora precisamos de uma forma única de acessar uma instância dessa classe, para isso, vamos criar uma função e uma variável global privada para armazenar a instância. É importante que a função e variável fiquem, respectivamente, acima e abaixo da seção implementation, "blindando" o acesso a variável e a classe.

function GetSingleton: ISingleton;

implementation

var
  _Singleton: ISingleton = nil;

function GetSingleton: ISingleton;
begin
  if (_Singleton = nil) then
    _Singleton := TSingletonInterface.Create;

  Result := _Singleton;
end;

Ao meu ver, essa é uma implementação melhor do que a do post anterior, pois o Singleton deixa mais claro sua intenção, seus métodos fazem exatamente o que está descrito, e por ser uma interface não existem os métodos Create e Free, que são públicos em TObject.

O código completo do exemplo pode ser acessado aqui.

Singleton em Delphi

2011-08-02T16:27:00.000-07:00

O Singleton é um padrão de projeto utilizado para garantir que apenas uma única instância de determinada classe esteja disponível em todo o projeto, ou seja, ele garante que o objeto será instanciado apenas uma vez e será acessivel de forma global.

Isso é muito útil, por exemplo, quando lidamos com factory, pois a factory não precisa ser instanciada a todo momento. Outros exemplos são Pool de Conexões, Registry, Logs, ou recursos que sejam caros de instanciar a cada uso.

Contudo, há sempre muita controvérsia em torno da utilização do pattern singleton, isto porque ele é frequentemente mau empregado na solução dos problemas, fazendo com que o mesmo se torne apenas uma "variável global" e isso pode indicar que você tem um design pobre.

Há pelo menos duas formas diferentes em delphi de implementar este padrão. Primeiro vou mostrar como implementar utilizando uma classe comum, que possui um método estático - GetInstance() - que retorna a instância da classe.

type
  TSingleton = class
  private
    FCanFree: Boolean;

    class procedure InternalFree;
  public
    procedure FacaAlgo;

    class function GetInstance: TSingleton;

    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
  end;

implementation

//Variável para armazenar a instância do Singleton
var
  _Singleton: TSingleton = nil;

{ TSingleton }

//Lógica de negócio
procedure TSingleton.FacaAlgo;
begin
  if IsConsole then
    Writeln(ClassName, ' Fazendo algo')
  else
    ShowMessageFmt('%s Fazendo algo',[ClassName]);
end;

//Indica que o objeto pode ser destruído
class procedure TSingleton.InternalFree;
begin
  if Assigned(_Singleton) then
  begin
    _Singleton.FCanFree := True;
    _Singleton.Free;
  end;
end;

//Só libera a instância quando o método InternalFree é chamado
procedure TSingleton.FreeInstance;
begin
  if FCanFree then
  begin
    inherited;
  end;
end;

//Na verdade o create vai invocar o método NewInstance indiretamente
class function TSingleton.GetInstance: TSingleton;
begin
  Result := TSingleton.Create;
end;

//Instanciação Preguiçosa - Só instancia o objeto quando alguém precisar
class function TSingleton.NewInstance: TObject;
begin
   if (_Singleton = nil) then
     _Singleton := TSingleton(inherited NewInstance);

   Result := _Singleton;
end;

initialization

finalization
  TSingleton.InternalFree;

Essa abordagem é relativamente simples, mais traz consigo alguns problemas em relação a deixar o código claro. O singleton não respeita o "contrato" descrito por seu métodos, isto é, quando eu chamo o método create, ele não cria um novo objeto e quando eu invoco o método Free, ele não destroy o objeto. Isso pode causar uma certa confusão na utilização do mesmo.

Vamos dar uma olhada em um código de teste para garantir que a instância é única.

type
  TTestSingleton = class(TTestCase)
  private
  published
    procedure GetInstanceDeveRetornarUmaInstancia;
    procedure GetInstanceECreateDeveRetornarAMesmaInstancia;
    procedure FreeNaoPodeDestruirInstancia;
    procedure DestroyNaoPodeDestruirInstancia;
    procedure FreeInstanceNaoPodeDestruirInstancia;
  end;
  
{ TTestSingleton }
  
procedure TTestSingleton.DestroyNaoPodeDestruirInstancia;
var
  vInstance,
  vInstanceAfterFree: TSingleton;
begin
  vInstance := TSingleton.GetInstance;
  vInstance.Destroy; //Não tem efeito
  vInstanceAfterFree := TSingleton.GetInstance;

  CheckTrue(vInstance = vInstanceAfterFree);
end;

procedure TTestSingleton.FreeInstanceNaoPodeDestruirInstancia;
var
  vInstance,
  vInstanceAfterFree: TSingleton;
begin
  vInstance := TSingleton.GetInstance;
  vInstance.FreeInstance; //Não tem efeito
  vInstanceAfterFree := TSingleton.GetInstance;

  CheckTrue(vInstance = vInstanceAfterFree);
end;

procedure TTestSingleton.FreeNaoPodeDestruirInstancia;
var
  vInstance,
  vInstanceAfterFree: TSingleton;
begin
  vInstance := TSingleton.GetInstance;
  vInstance.Free; //Não tem efeito
  vInstanceAfterFree := TSingleton.GetInstance;

  CheckTrue(vInstance = vInstanceAfterFree);
end;

procedure TTestSingleton.GetInstanceDeveRetornarUmaInstancia;
var
  vInstance: TSingleton;
begin
  vInstance := TSingleton.GetInstance;
  CheckNotNull(vInstance, 'Retornou nil');
  CheckTrue(vInstance is TSingleton, 'Não é um TSingleton');
  vInstance.FacaAlgo;
end;

procedure TTestSingleton.GetInstanceECreateDeveRetornarAMesmaInstancia;
var
  vFromGetInstance,
  vFromCreate: TObject;
begin
  vFromGetInstance := TSingleton.GetInstance;
  vFromCreate := TSingleton.Create; //Retorna a mesma instancia

  CheckTrue(vFromGetInstance = vFromCreate);

  vFromCreate := TSingleton.NewInstance; //Retorna a mesma instancia
  CheckTrue(vFromGetInstance = vFromCreate);
end;

No próximo post vou mostrar o segundo tipo de implementação, utilizando interfaces.

Por hoje era isso, até a próxima e usem o Singleton com moderação.

Usando DUnit para implementar testes unitários - Parte 2

2011-08-01T19:03:00.000-07:00

No último post fiz uma introdução sobre a criação de testes unitários com o DUnit. Hoje, vou explorar mais alguns recursos desta poderosa ferramenta, continuando com o exemplo da Calculadora, para isso, a calculadora vai ganhar um método para fazer divisão. Lembram do ritual? Red - Green - Refactor! Vejam a classe de teste, garanta que o teste falhe e então faça-o passar.

procedure TTestCalculadora.DivisaoDe6Por2DeveSer3;
var
 vCalculadora: TCalculadora;
begin
 vCalculadora := TCalculadora.Create;
 try
   CheckEquals(3, vCalculadora.Soma(6).DividePor(2).GetTotal, 'Divisão inválida');
 finally
   vCalculadora.Free;
 end;
end;

Fail!

function TCalculadora.DividePor(const AValor: Double): TCalculadora;
begin
  FValor := FValor / AValor;
  Result := Self;
end;

Success!

E o que acontece se eu tentar uma divisão por zero?

procedure TTestCalculadora.DivisaoDe6PorZero;
var
 vCalculadora: TCalculadora;
begin
 vCalculadora := TCalculadora.Create;
 try
   vCalculadora.Dividir(6, 0);
 finally
   vCalculadora.Free;
 end;
end;

Isso não parece bom. Rode o teste e veja que será lançada uma exceção do tipo EZeroDivide - se fosse um Integer lançaria uma EDivByZero - e o teste falhará.

Para esse tipo de teste, o DUnit oferece um recurso bastante útil, o ExpectedException, onde declaro que estou esperando uma exceção de determinado tipo. Se a exceção não for lançada, o teste falhará. Então vamos alterar o código e agora o mesmo deve passar.

procedure TTestCalculadora.DivisaoDe6PorZero;
var
 vCalculadora: TCalculadora;
begin 
 ExpectedException := EZeroDivide; 
 vCalculadora := TCalculadora.Create;
 try
   vCalculadora.Dividir(6, 0);
 finally
   vCalculadora.Free;
 end;
end;

Esses testes nos trouxeram a tona um problema de design em nossa classe de teste, a duplicação, não estamos sendo DRY. Em cada teste implementado estamos instanciando e destruindo o objeto Calculadora. Vamos extrair isso para outros métodos.

A classe TTestCase da qual estamos herdando possue dois métodos adequados para o que precisamos: SetUp e TearDown. O SetUp é onde preparamento o teste - instanciar a calculadora. O TearDown é onde limpamos a sujeira - destruir a calculadora. É importante ressaltar que esses métodos são disparados para cada teste da suíte.

Refatorei a classe de teste, e ela ficou assim. Rode os testes e veja se continua tudo funcionando.

type
  TTestCalculadora = class(TTestCase)
  private
    FCalculadora: TCalculadora;
  protected
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure SomaDe2Mais3DeveSer5;
    procedure DeveResetarOValor;

    procedure DivisaoDe6Por2DeveSer3;
    procedure DivisaoDe6PorZero;
  end;

implementation

uses SysUtils;

{ TTestCalculadora }

procedure TTestCalculadora.SetUp;
begin
  inherited;
  FCalculadora := TCalculadora.Create;
end;

procedure TTestCalculadora.TearDown;
begin
  FCalculadora.Free;
  inherited;
end;

procedure TTestCalculadora.DeveResetarOValor;
begin
  FCalculadora.Soma(1).Reset;
  CheckEquals(0, FCalculadora.GetTotal, 'Não resetou o valor');
end;

procedure TTestCalculadora.DivisaoDe6Por2DeveSer3;
begin
  CheckEquals(3, FCalculadora.Soma(6).DividePor(2).GetTotal, 'Divisão inválida');
end;

procedure TTestCalculadora.DivisaoDe6PorZero;
begin
  ExpectedException := EZeroDivide;
  FCalculadora.Soma(6).DividePor(0);
end;

procedure TTestCalculadora.SomaDe2Mais3DeveSer5;
begin
  CheckEquals(5, FCalculadora.Soma(2).Soma(3).GetTotal);
end;

Existem ainda varias outras opções de métodos de validação além do CheckEquals, alguns dos mais usados são

procedure CheckTrue(condition: Boolean; msg: string = ''); 
    procedure CheckFalse(condition: Boolean; msg: string = ''); 
    procedure CheckNotEquals(expected, actual: integer; msg: string = ''); 
    procedure CheckNotNull(obj: TObject; msg: string = ''); 
    procedure CheckNull(obj: TObject; msg: string = ''); 
    procedure Fail(msg: sTring; ErrorAddrs: Pointer = nil);

O código fonte dos exemplos está disponível aqui. Até o próximo post, abraços e bons testes.

Usando DUnit para implementar testes unitários

2011-08-01T18:33:00.000-07:00

Esse é meu primeiro post, e vou começar abordando um assunto que ao meu ver é pouco difundido na comunidade Delphi, Testes Unitários, e para isso vou demonstrar como utilizar a ferramenta DUnit para construção dos testes.

Cada vez mais é primordial que o desenvolvedor invista parte de seu tempo na construção de testes, se for utilizando TDD, melhor ainda. Uma boa suíte de teste nos dá segurança e confiança no momento de fazer um refactoring ou a correção de um bug. Também melhora significativamente o design do nosso código, pois, para pode testar de forma realmente unitária, nossas classes precisam ter baixo acoplamento, boa coesão, serem realmente testáveis.

Vou criar um exemplo de calculadora inspirado no padrão Builder seguindo os passos do TDD - Red, Green, Refactor. Primeiro vamos escrever a classe de teste, e está deverá falhar antes da implementação da calculadora em si.

type
 TTestCalculadora = class(TTestCase)¹
 private
 published²
   procedure SomaDe2Mais3DeveSer5;  
 end;

implementation

{ TTestCalculadora }

procedure TTestCalculadora.SomaDe2Mais3DeveSer5;
var
 vCalculadora: TCalculadora;
begin
 vCalculadora := TCalculadora.Create;
 try
   CheckEquals(5, FCalculadora.Soma(2).Soma(3).GetTotal);
 finally
   vCalculadora.Free;
 end;
end;

initialization
  RegisterTest('Calculadora', TTestCalculadora.Suite);³

¹A classe deve herdar de TTestCase, que faz parte do framework DUnit. ²Os métodos que implementam os testes devem ser declarados na seção published, para que possam ser lidos utilizando RTTI. ³A classe deve ser registrada.

Vamos ver se o teste falha. Para os mais puristas, o código não compilar já é o suficiente para a fase Red, eu particularmente, gosto de fazer a implementação suficiente para compilar o código, de qualquer modo, é importante garantir que o teste falhe. Então vou criar a classe calculadora mais não vou implementar o método GetTotal e no método Soma apenas vou retornar a Calculadora para não obter um Access Violation.

type
  TCalculadora = class
  private
  public
    function Soma(const AValor: Double): TCalculadora;
    function GetTotal: Double;
  end;

implementation

{ TCalculadora }

function TCalculadora.GetTotal: Double;
begin
end;

function TCalculadora.Soma(const AValor: Double): TCalculadora;
begin
  Result := Self;
end;

Rodando o teste, o mesmo vai falhar, pois o método retorna um valor qualquer atribuído em tempo de execução. Veja na imagem abaixo.

Agora vamos implementar o método Soma e GetTotal e rodar o teste novamente.

type
  TCalculadora = class
  private
    FValor: Double;
  public
    function Soma(const AValor: Double): TCalculadora;
    function GetTotal: Double;
  end;
  
function TCalculadora.GetTotal: Double;
begin
  Result := FValor;
end;

function TCalculadora.Soma(const AValor: Double): TCalculadora;
begin
  FValor := FValor + AValor;
  Result := Self;
end;

O mesmo deve passar, como na imagem a seguir.

Estamos indo bem, vamos escrever mais um teste, vamos criar um método para resetar o valor. Aqui está o nosso teste.

procedure TTestCalculadora.DeveResetarOValor;
var
 vCalculadora: TCalculadora;
begin
 vCalculadora := TCalculadora.Create;
 try
  vCalculadora.Reset;
  CheckEquals(0, vCalculadora.GetTotal, 'Não resetou o valor');
 finally
   vCalculadora.Free;
 end;
end;

Crie o método Reset na classe calculadora, mais não implemente.

function TCalculadora.Reset: TCalculadora;
begin
end;

Agora rode o teste e você pode ver que... o teste passa. Mesmo sem implementação, ele passa. Por isso é tão importante garantir que o teste falhe antes de implementar, só assim ele tem valor. Um teste que passa antes mesmo de implementar não testa nada, não agrega valor algum. Vamos corrigir isso de modo que o teste falhe.

procedure TTestCalculadora.DeveResetarOValor;
var
 vCalculadora: TCalculadora;
begin
 vCalculadora := TCalculadora.Create;
 try
  vCalculadora.Soma(1).Reset;
  CheckEquals(0, vCalculadora.GetTotal, 'Não resetou o valor');
 finally
   vCalculadora.Free;
 end;
end;

Rode o teste e veja que o mesmo vai falhar. Feito isso vamos implementar o método Reset adequadamente para que o teste passe.

function TCalculadora.Reset: TCalculadora;
begin
  //Evitando número mágicos
  FValor := ZeroValue;
  Result := Self;
end;

Ainda há vários recursos do DUnit a serem explorados mais vou deixar isso para um próximo post, onde mostrarei também como testar exceções conhecidas.

Não deixem de postar sobre dúvidas ou sugestões e escrevam testes. ;D

Abraços.