Faz alguns meses, e decidimos, eu e o Emanuel Zabka, implantar o TDD no desenvolvimento na empresa em que trabalhamos. Academicamente é falado muito em refactoring e mudanças de requisitos, mas na prática, eu nunca havia notado a quantidade de modificações que um mesmo código/classe/arquivo é modificado num curto período de tempo e a longo prazo.

Os testes me ajudaram a enxergar, não só as dependências do sistema, como também, acoplamentos desnecessários; a qualidade dos códigos; do design do projeto; e, consequentemente, diminuiu muito os bugs mais corriqueiros, como validação de campos. Mesmo tendo várias coisas boas, há coisas ruins, como aumento do tempo de desenvolvimento – o que, apesar de nunca ter medido, diminui o retrabalho e tempo utilizado no futuro em correções de bugs -, aumento da complexidade da arquitetura – a fim de manter uma maior coesão com baixo acoplamento, entre outros menos relevantes.

Unit Test

The basic concept of unit testing is write more code which will test the main code we’ve written, by “throwing” sample data at it and examining what it gets back.

Harry Fuecks

Enfim, uma boa definição de testes unitários é esta supracitada. São escritos mais códigos para testar o código principal, utilizando dados de testes para analisar o comportamento e o retorno do código sendo testado.

CakePHP

• Framework de desenvolvimento rápido pra Web com PHP
• Utiliza padrões MVC e ORM
• Extensível para desenvolvimento, manutenção e deploying.
• OpenSource / Comunidade muito ativa e amigável
• Orientada a Objetos
• Mais detalhes sobre o CakePHP

SimpleTest

• Praticamente mesma coisa que JUnit, JMock e PHPUnit.
• Guiado através de asserções
• Possibilidade navegação em requisições HTTP para testar interface gerada (HTML)
• OpenSource
• Orientada a Objetos
• Mais detalhes sobre o SimpleTest

CakePHP e SimpleTest

• Startup (criação do arquivo, casos de testes básicos) dos testes unitários automaticamente
• Customizações no template de Report (Web com template padrão)
• Rápida execução de testes individualizados
• Rápida execução de grupos de testes (execução de vários testes unitários sequencialmente)
• Pode-se usar Mock para objetos internos do CakePHP ou da aplicação
• Pode-se testar aplicação toda (APP + Plugins)
• Pode-se testar somente a aplicação (APP)
• Pode-se testar plugins separadamente
• Pode-se testar em modo batch
• Integração dos dois frameworks

Convenções e Padrões

Para o SimpleTest não há padronização no nome dos arquivos, mas o CakePHP estabelece um a partir da convenção das classes utilizados por ele. Ex: respectivamente as classes de controller e model de um Post:

PostController

tests/cases/controllers/post_controller.test.php

Post

tests/cases/models/post.test.php

• O nome da classe contida no arquivo é derivado a partir do nome do mesmo.
• Esta classe deve extender a classe CakeTestCase ou CakeWebTestCase
• A assinatura dos métodos que contém asserções (métodos de teste) devem iniciar com “test”, como em testPostControllerAddPost().
• Métodos que são executados como eventos:

  start()

  Primeiro método chamado. Executado quando se iniciam os testes

  end()

  Último método chamado. Executado quando se concluí todos os casos testes

  startCase()

  Executado antes do caso de teste começar a ser testado (lembrando que um teste pode ser composto de um ou mais casos de teste)

  endCase()

  Executado depois que o caso de teste foi testado por completo

  before($method)

  Anuncia o início de um método de teste

  after($method)

  Anuncia o término de um método de teste

  startTest($method)

  Executado antes de um caso de teste iniciar

  endTest($method)

  Executado depois que um caso de teste termina

Mais detalhes sobre as convenções

Fixtures

Fixtures são uma forma de utilizar dados de teste. São matrizes de dados que correspondem à registros em um banco de dados.
Cada Model possui uma Fixture, que irá não só ter os dados como a representação dos campos que compõe a tabela do banco, pois a partir destes dados o framework irá:

1. Criar uma tabela prefixada (por padrão) de “test_suite_” no banco de dados para cada fixture necessário (ou seja, cada model utilizado).
2. Inserir os dados de teste na tabela de teste
3. Executar os testes em cima destes registros
4. Remover os dados da tabela de teste
5. Remover a tabela no banco de dados.

Ou seja, assim é garantido que os dados serão sempre os mesmos e que não comprometerá a base de dados atual com sujeira, podendo-se executar
estes testes a qualquer momento atrás de problemas. Testes que envolvem banco de dados com índices únicos, chaves primárias ou outras constraints
estão livres de erros (erros não propositais) durante os testes.

Veja mais sobre Fixtures

Asserções

• assertTrue($x)
• assertFalse($x)
• assertNull($x)
• assertEqual($x, $y)
• assertIsA($object, ‘ClassName’)
• assertIdentical($x, $y)
• assertPattern(’/REGEX/’, $x)
• expectError();

Se você se interessou, para mais detalhes sobre os testes unitários no CakePHP, recomendo a leitura deste post da Debuggable: Unit Testing in CakePHP Part 1 – Introduction to Unit Testing

Agradecimentos especiais a André Leitzke e Viviane de Souza por terem me ajudado com a caracterização e descrição do framework!

Eu já tinha lido sobre uma opção do Vim chamada keywordprg, mas nunca havia encontrado uma serventia. Quando eu li no blog do bjori, realmente me veio à mente como eu poderia utilizá-la.

Eu instalei a última versão do pear aqui, e executei os comandos que ele cita no blog:

pear install doc.php.net/pman

Eu precisei aumentar a memória do php.ini (memory_limit), 32M não foi o suficiente.

O manual será instalado no diretório especificado em “doc_dir” da configuração da pear e o executável no “bin_dir“. Para verificar as configurações atuais:

pear config-show # Mostra todas as configurações atuais
pear config-get bin_dir # Mostra configuração atual da opção bin_dir
pear config-get doc_dir # Mostra configuração atual da opção doc_dir
# Para modificar:
pear config-set bin_dir /outro/bin
pear config-set doc_dir /outro/docs

Depois de instalado, você pode utilizar ele tanto no Vim quanto fora do Vim:

pman array_merge

Bom, se lembra que eu havia falado sobre o keywordprg ? Assim como o makeprg é o programa executado ao se executa :make no Vim e o grepprg o comando executado ao se executar :[grep|vimgrep], o keywordprg é executado quando se preciona K (k maiúsculo) sobre alguma palavra chave – que no nosso caso será uma função php.

O artigo citado ali em cima, indica para colocarmos no .vimrc, mas eu acho mais interessante por no .ftplugin/php.vim (se o arquivo não existir, crie). Assim, só será carregado caso o tipo do arquivo for php, possibilitando utilizar outros programas para outras linguagens

" Programa executado quando pressionado K
set keywordprg=pman

Agora faça o teste: abra um arquivo php, coloque o cursor sobre alguma função e pressione K. Para fechar o manual aberto, basta precionar q. Pode-se utilizar a busca com /termo e também navegar nos resultados com n/N. j/k/UP/DOWN movem o arquivo para cima e para baixo, normalmente, como se fosse um manpage.

Eai, este post ajudou em algo?

Expressões Regulares

Expressão regular é uma ferramenta muito forte para o tratamento de texto. É muito utilizado para substituições ou para verificar integridade dos dados, pois, através da expressão regular, vulga regex ou re, pode-se casar padrões de texto. Por exemplo:

/^[a-zA-Z0-9]+$/
Para somente caracteres alfanuméricos.
 
/^(\d{3}\.){2}\d{3}-\d{2}$/
Validando formato de CPF.

Esse tipo de regex é simples, valida praticamente só os caracteres que compõe uma dada string. Porém, as Perl Compatible Regular Expressions (Expressões Regulares Compatíveis com Perl), também conhecidas como pcre, permitem muito mais, inclusive utilizar condicionados (if’s), porém isso é para outro post! O que vamos falar agora é de Lookahead e Lookbehind.

Lookahead

Lookahead é uma forma de casar strings que tenham ou não um determinado final. É utilizado (?⁼…) para o positivo, ou seja, que terminem com; e (?!…) para o negativo, ou seja, que não termina com.

Um exemplo simples, seria a busca, primeiramente, de Gustavo seguido por Dutra. Se existisse Gustavo ou Gustavo Outracoisa, ele não casaria. Ao contrário, o segundo exemplo somente casaria o Gustavo ou o Gustavo Outracoisa, porém não casaria o Gustavo Dutra:

/Gustavo(?= Dutra)/
/Gustavo(?! Dutra)

Vamos ver um exemplo mais funcional e complexo em python:

import re
print re.findall(r'\s?([^;]+);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Firefox Browser', 'Emacs Editor', 'Thunderbird Email']

Mas e se quisesse somente os editores da lista?

import re
print re.findall(r'\s?([^;]+ Editor);', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Vim Editor', 'GVim Editor', 'Emacs Editor']

Mas e se eu quisesse todos MENOS os editores? É ai que entra o Lookahead, vamos pegar todos que não terminam com Editor.

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Observem que o que casar com (?!Editor) não entra no resultado, para incluí-lo, seria necessário uma expressão regular um pouco mais complexa utilizando condicionais. Veremos isso depois!

Lookbehind

Lookbehind faz o mesmo que o lookahead, porém, como o próprio nome diz, não procura depois, mas sim antes, da string dita. (?<=…) para o positivo e (?<!…) para o negativo.

Vamos pegar um RT de um tweet do twitter.com. Como gosto de ser eclético, vou usar perl:

print "RT \@gustavotkg Testando ERs." =~ /(?< =@)gustavotkg/
# Output seria:
1

Essa expressão retorna 1 (ou seja, TRUE), caso exista algum gustavotkg precedido por uma @.

OBS: @ são escapadas porque representam variáveis do tipo array em perl.

print "Este é um RT \@gustavotkg Testando ERs." =~ /(?< !RT )\@gustavotkg/
# Output seria, vazio, pois o @gustavotkg é precedido por um RT
 
print "RT \@gustavotkg2 também estou testando ERs." =~ /(?<!^RT \@gustavotkg\b)(.+)$/
# Output seria:
RT @gustavotkg2 também estou testando ERs.

O \b significa borda de palavra (espaço, ponto final, exclamação, final de linha, etc). Como 2 não é uma borda de palavra, pois a expressão regular diz o seguinte: "Case com tudo que não começar com RT @gustavotkg seguido de uma borda de palavra".

Condicionais

Como se pode notar nos casos acima, os operadores de lookahead e lookbehind não colocam o valor casado junto ao resultado final. Para isso temos que verificar condicionalmente e adicionar manualmente o valor. A sintaxe é esta: (?(condicao)(caso verdadeiro)|(caso falso)).

Parece complicado, mas é bem simples, vamos começar com algo fácil utilizando php:

preg_match("/(?(?< =@)\w+|\w{2})/", "@testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "testando"
}
 
preg_match("/(?(?< =@)\w+|\w{2})/", "testando", $r);
var_dump($r);
# Output seria:
array(1) {
  [0]=> string(8) "te"
}

Notem o condicional: Se começar (lookbehind) com @, então quero que case toda a palavra que segue o @, caso contrário, quero apenas os dois primeiros caracteres. Fácil? Vamos complicar!

Lembra do exemplo mais acima do lookahead? Vou refrescar a memória:

import re
re.findall(r'\s?([^;]+ (?!Editor))', 'Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;')
# output seria:
['Firefox ', 'Thunderbird ']

Notem que ela não adicionar a categoria do Firefox nem do Thunderbird, pois o (?!) como supracitado, não é colocado junto no resultado final. Para adicioná-los, podemos usar o condicional.

preg_match_all("/(\w+ (?(?!Editor)\w+));/","Vim Editor; GVim Editor; Firefox Browser; Emacs Editor; Thunderbird Email;",$e);
var_dump($e);
// Output seria:
array(2) {
  [0]=>
  array(2) {
    [0]=>
    string(16) "Firefox Browser;"
    [1]=>
    string(18) "Thunderbird Email;"
  }
  [1]=>
  array(2) {
    [0]=>
    string(15) "Firefox Browser"
    [1]=>
    string(17) "Thunderbird Email"
  }
}

Ou seja, no segundo índice do array, que na verdade é o indice 1, consta o resultado pego. Veja que utilizamos o seguinte método: Se \w+ não for seguido de 'Editor' então pega o \w+, senão ignora pois não é para casar. Assim, se for Editor, ele nunca irá casar.

Dúvidas? Sugestões? Deixe um comentário!

Controle de Versão

• SVN Cheat Sheet
• Git Cheat Sheet
• Mercurial Cheat Sheet
• Bazaar Cheat Sheet

Frameworks

• Prototype Cheat Sheet
• MooTools Cheat Sheet
• jQuery Cheat Sheet
• Ruby On Rails
• Django Cheat Sheet
• CodeIgniter Cheat Sheet
• CakePHP Cheat Sheet
• Mais de 12 Symfony Cheat Sheets

Programação

• Bash Script Quick Refences
• AWK Cheat Sheet
• HTML5 Canvas Cheat Sheet
• PHP Cheat Sheet
• Ruby Quick Refence
• 9 Perl Cheat Sheets
• Python Quick Refence
• Regular Expression Cheat Sheet

Web Design

• Font Size Cheat Sheet
• Propriedades CSS
• HTML Char Entities Cheat Sheet
• 6 Design Colors Cheat Sheet
• SEO Web Developer Cheat Sheet

Bancos de Dados

• XML Schema Structure Quick Refence
• MySQL Cheat Sheet
• PostgreSQL Cheat Sheet

Ferramentas

• Google Search Cheat Sheet
• Firebug Cheat Sheet
• Vimperator Cheat Sheet
• LaTeX Cheat Sheet
• Vim Cheat Sheet
• Vim Quick Refence
• mod_rewirte Cheat Sheet

Alguma que eu tenha esquecido? Posta ae nos comentários!

Baseado nisso e no comentário que recebi recentemente e inspirado pelo post de um amigo, vou fazer uma lista de coisas que proponho. São coisas simples, mas que facilitam na manutenção.

Umas das coisas que aprendi com Uncle Bob (Robert C. Martin), no seu livro Clean Code foi: escrevemos o código apenas uma vez, porém o mesmo é lido várias vezes. Então, não custa usarmos 5min a mais documentando alguma coisa ou escrevendo variáveis legíveis, que nos pouparão tempo mais tarde!

1. Clareza e objetivadade nos nomes das variáveis

É incrível como as pessoas conseguem dar nomes criativos para variáveis. O alfabeto tem tantas letras que formam tantas palavras, por que insistem em usar apenas 1 letra como nome de variável? Pior, Por que usar sempre as mesmas?

$d = 3;
$dias = 2;

A primeira variável simplesmente não diz nada. Olhando ela não se consegue ter noção nenhuma do que ela representa, o que é o 3? Do mesmo modo se aplica a segunda variável, sabemos que são 2 dias, mas 2 dias não nos diz nada também. Olhando assim, só sabemos a unidade de medida!

$dia_vencimento = 3;
$qtde_dias_para_pagamento  = 2;

Há quem reclame do tamanho das variáveis. Mas hoje em dia, que editor não auto-completa para você? Se o seu não, por favor, considere trocar =).

O que se deve cuidar ao se nomear uma variável, é não por algum nome que venha a ter mais de uma possibilidade de significado. Por exemplo:

$valor_frete_desconto = 11.3;

O valor acima citado, é referente ao desconto dado ao frete, ao valor do frete a ser descontado ou o valor do frete com o desconto? Eu não afirmo nenhuma hipótese à partir do nome dado. Se me perguntarem, eu diria que olharia o código para afirmar. Por tanto, seja CLARO E OBJETIVO.

$valor_frete = 13.4;
$valor_desconto_frete = 2.3;
$valor_frete_descontado = $valor_frete - $valor_desconto_frete;

Caso o desconto do frete seja aplicado com porcentagem:

$pct_desconto_frete = 10;
$valor_frete = 13.4;
$valor_desconto_frete = $valor_frete * ($pct_desconto_frete / 100);
$valor_frete_descontado = $valor_frete - $valor_desconto_frete;

A melhor coisa em relação às variáveis é justamente o fato de omitir o valor atrás de um nome inteligível. Por tanto, sempre que possível, esconda os valores, a legibilidade aumenta muito!

    $arr_usrs = array();
    for ($i = 0; $i < count($users); $i++) {
        if ($users[$i][3] == 4)
            $arr_usrs[] = $users[$i];
    }
    return $arr_usrs;
}

Pergunto:

• $arr_usrs é uma lista gerada à partir de que dados?
• O que é o índice 3 do array usado no if ?
• O que diabos quer dizer == 4?
• O que devo esperar que $arr_usrs contenha?

define("STATUS", 3);
define("ATIVO", 4);
    $contatosAtivos = Array();
    for ($i = 0; $i < count($contatos_do_usuario); $i++) {
        $contato = $contatos_do_usuario[$i];
        $status_do_contato = $contato[STATUS];
        if ($status_do_contato == ATIVO)
            $contatosAtivos[] = $contato;
    }
    return $contatosAtivos;

Acho que não preciso explicar o código, não é?

Outra coisa interessante, CUIDADO com as variáveis de duplo sentido.

$total = count($usuariosDoBanco);

$total recebeu o total de usuários do Banco de Dados ? o total de usuários de um determinado banco (BB, Santander, etc) ?

Sugestão:

$total = count($usuarios_cadastrados);

ou, para o outro caso

$total = count($clientes_santander);

Eu sei que muitas vezes é difícil escrever códigos de forma bonita, mas o esforço vale a pena! Além de ser um diferencial profissional, trabalhar no meio da zona é prejudicial a você mesmo!

Lembrou de algo? Tens outras dicas? Comenta aê!

Parece radical, mas a produtividade aumenta, de certo modo. Não só na hora de programar e testar, sempre que edito arquivos no Vim, tento não usar o mouse. Claro que sempre vai ter alguma aplicação que vai te obrigar a usar o mouse, mas se pudermos evitar, melhor!

Eu continuo com esta idéia. Coisinha bonita é para cliente final. Desenvolvedores devem trabalhar com ferramentas que proporcionam o melhor uso do tempo possível, pois o bom profissional é aquele que esbanja do ócio, eis o fluxo:

• Concluir as atividades rapidamente com eficácia e eficiência está diretamente ligado ao ócio, pois se ele tivesse feito algo mal feito, estaria corrigindo os bugs e não vendo vídeos no youtube.
• Com tempo livre, o cérebro humano fica mais descansado e mais propício a receber insights/intuições para resolver problemas difíceis, que – e estes merecem – precisam de mais tempo e necessitam ser bem planejados.
• Resolvendo problemas de forma criativa – talvez até inovadora -, faz com que se evite problemas futuros. Logo, se poupa tempo. Se poupando tempo, voltamos a cláusula anterior.

Parece utópico, mas eu acredito nisso. Eu acho que é possível. Basta saber onde conseguir ganhar tempo em atividades, automatizando com scripts, programas e etc, o tempo é consequência.

Todo Desenvolvedor Web já foi ou ainda é DBA. É inevitável aprender a utilizar banco de dados sem modelar os dados. Geralmente, para isso, é utilizado alguma ferramente gráfica que auxilia na visão do modelo. Não vou citar, mas existem várias para isso.

Porém, há um detalhe que muitos não se atinaram ainda. Me dei conta disso assistindo uma palestra no FISL10, na palestra do Leandro Dutra (se for parente, é primo de muitos graus :S) chamada O elefante ilustrado: modelagem literária e documentação automática em PostgreSQL e outros SGBDs livres.

SchemaSpy

O que é?

É uma ferramente que varre um banco de dados e gera um documentação em HTML nevegável. Ela gera gráfico de chaves estrangeiras utilizando o GraphViz (.dot), como se fosse uma dessas ferramentas que terminam com Designer.

Esses gráficos gerados, são visivelmente bonitos e dispostos. Ou seja, não é mais necessário sofrer arrastando caixinhas de modo com que fique bem arrumado. O programa tem um bom algoritmo para organizar. O que possibilita que o DBA, ou o desenvolvedor mesmo, use este tempo para repensar uma constraint, uma foreign key, etc.

O HTML gerado também tem abas que diferenciam os conteúdos: abas para relacionamentos, abas para tabelas auxiliares, abas para listagem de colunas/tabelas, etc. Mostra os campos, o tipo dos campos, os comentários, valores em comum e as CONSTRAINTS. Ou seja, uma solução completa para documentação de bancos de dados e modelos de ER. Vem junto o jQuery, que da uns efeitos e toggleia algumas colunas das tabelas de exibição.

Onde conseguir?

O site oficial deles é http://schemaspy.sourceforge.net. Pode ser baixado de lá. Apenas o driver jdbc para o banco de dados que for ser usado deve ser encontrado separadamente.

Quem usa ArchLinux, pode baixar os repositórios do AUR. Eu mesmo sou o mantenedor do pacote, então, qualquer dúvida ou problema, comente lá que tentarei responder/resolver o mais rápido possível. O link do repositório é http://aur.archlinux.org/packages.php?ID=28022

Como usar?

Para usar é muito simples. Depois de baixar o .jar, apenas execute

$ java -jar /path/to/schemaSpy.jar --help

Ou, se você instalou o do repositório do ArchLinux, basta usar:

$ schemaspy --help

Ele vai listar os parâmetros, é bem simples. Não vou me deter a isso. Qualquer dúvida comente no post abaixo.

Um exemplo de output pode ser encontrado na própria página do SchemaSpy: http://schemaspy.sourceforge.net/sample/

Sugestoẽs

Se existe algum defeito nele, com certeza é o template. O HTML gerado não é o mais bonito. Não obstante, me parece que o template não é customizável, para isso seria necessário hackear a classe que gera o template. Mas, quem sabe não é implementado algo nas próximas versões? Quem sabe VOCÊ não implementa?

Mas bem, falando em sugestões, aqui vai algumas:

• Integrar com a documentação do phpDocumentor, javaDoc ou outro similar.
• Versionar a documentação gerada para avaliação de crescimento da aplicação: poder comparar como era há certo tempo atrás e como está hoje.
• Programar os SQL’s utilizando algum editor de texto, fazendo você ganhar desempenho e analisar mais facilmente para comentários, constraints, triggers, procedures e views, que são geralmente mais complexas de serem vistas em programas gráficos.

Mais alguma sugestão? Críticas? Deixem nos posts abaixo!

Porém, como todos os outros artefatos que estão por aí, pode complicar ainda mais a vida de um programador, caso não seja usado adequadamente.

Introdução

Como visto no post anterior, onde está descrito algumas vantagens e desvantages de se usar o mod_rewrite, neste post vamos concluir o assunto. Assumindo que você esteja usando Apache com o mod_rewrite habilitado. Também é necessário o uso de arquivos .htaccess: Arquivos ocultos que contém diretivas interpretadas pelo Apache. Para que seu .htaccess funcione, deve se certificar de que a diretiva AllowOverride All esteja nos arquivos de configuração do apache. Ela deve ficar dentro de <Directory />, mais ou menos assim:

	AllowOverride All

Basta adicionar ao seus arquivos de configuração do apache ou requisitar seu servidor que o faça.

Conhecendo as diretivas

Antes de mais nada, vamos entender o que o mod_rewrite faz e é capaz de fazer, conhecendo seus parâmetros de configurações.

RewriteEngine on|off

Habilita(on) ou desabilita(off) o uso do módulo mod_rewrite.

RewriteOptions [inherit] [MaxRedirects=X]

Adiciona uma ou as duas opções.

inherit

Herda os parâmetros dos diretórios pai.

MaxRedirects=X

Ao invés de permitir o ‘loop infinito’ de redirecionamento, limita para X vezes. Caso, X seja alcançado, é disparado erro 500 (Internal Error).

RewriteLog /caminho/para/arquivo.log

Escreve o log dos eventos ocorridos no arquivo especificado.

RewriteLogLevel Level

Level inicia em 0 (desabilitado) e vai até 9 (números superiores podem ser utilizados, mas terão o mesmo efeito: irão logar quase tudo! Use somente para debug, pois vai diminuir a performance do apache. Bom para testes/debug, não para produção.)

RewriteBase /dir

Especifica /dir como a base para a procura do arquivo pelo Apache. (Mais explicações adiante)

RewriteCond

Responsável pela condições (a.k.a. IF’s). Pode-se utilizar inúmeros testes antes de especificar uma regra, sendo que a mesma só será executada ao passar por todos os testes com sucesso. Exemplos:

# Se o host for 123.45.67.89
RewriteCond %{REMOTE_ADDR} ^123.45.67.89$ [OR]
# ou for 98.76.54.32
RewriteCond %{REMOTE_ADDR} ^98.76.54.32
# A regra será a seguinte...

Podem ser usadas uma série de variáveis, entre elas:

• %{HTTP_USER_AGENT}
• %{HTTP_REFERER}
• %{REMOTE_ADDR}
• %{SCRIPT_FILENAME}
• %{QUERY_STRING}
• %{HTTP_HOST}
• mais informações aqui

RewriteRule

É aqui que realmente acontece a reestruturação da URL. Aqui é onde é dito o que deve ser entrepretado como o quê. Se o Padrão casar, o apache interpreta como se fosse o Caminho.

Por exemplo:

RewriteRule ^/(about|aboutme|sobre|sobremim|eu|minhavida)$ eu.html [L,NC]

Referências interessantes:

• Documentação do Apache
• ModRewrite CheatSheet

Exemplos de uso

Agora, com alguma noção sobre o mod_rewrite, vamos utilizá-los. Com alguns exemplos do que é possível. A idéia é que você descubra um jeito próprio e que funcione PARA VOCÊ. Esta é o tipo da coisa que não adianta fazer porque alguém disse que funciona, deve seguir os seus padrões e cobrir suas necessidades.

Exemplo 1: Organizando seu site no .htaccess

Convenhamos: uma notícia sobre um acidente não irá mudar. Depois de submetida para um site de notícias, dificilmente ela irá ser modificada. Ao menos que tenha passado desapercebido um erro de português ou uma estatística imprecisa, uma notícia não será modificada. Portando, é possível manter um cache da notícia em um arquivo .html, evitando consultas desnecessárias a bancos de dados ou outras fontes. Mas só porque ela está em cache, não significa que ela deva aparecer com o .html no fim ou .htm ou seja lá o que for.

RewriteEngine On
RewriteBase /
# Se não foi requerido um arquivo vazio (-s)
RewriteCond %{REQUEST_FILENAME} !-s [OR]
# Se não foi requerido um link simbólico (-l)
RewriteCond %{REQUEST_FILENAME} !-l [OR]
# ou um arquivo (-f)
RewriteCond %{REQUEST_FILENAME} !-f [OR]
# ou um diretório (-d)
RewriteCond %{REQUEST_FILENAME} !-d
# Aplique a seguinte regra:
# Se for notícia cacheada, chama o cache
RewriteRule ^ler/([A-Za-z0-9_-]+)$ /noticias/cache/$1.html [L]
# Se for para buscar por noticias
RewriteRule ^buscar/([A-Za-z0-9_-]+) /noticias/busca.php?termo=$1&area=noticias [L]
# Feeds
RewriteRule ^feeds$ feeds.php?area=noticias
# Feeds para a categoria X
RewriteRule ^feeds/(.*)$ feeds.php?area=noticias&categoria=$1

e assim por diante. Podemos estabelecer regras, inclusive, para subdomínios.

RewriteCond %{HTTP_HOST} ^en\.example\.com$
RewriteRule ^(.*)$ /news/english/index.php?q=$1 [L]
 
RewriteCond %{HTTP_HOST} ^br\.example\.com$
RewriteRule ^(.*)$ /news/brazilian/index.php?q=$1 [L]

uma outra sugestão:

RewriteCond %{HTTP_HOST} ^en\.example\.com$
RewriteRule ^(.*)$ /news/index.php?lang=en&q=$1 [L]
 
RewriteCond %{HTTP_HOST} ^br\.example\.com$
RewriteRule ^(.*)$ /news/index.php?lang=pt-br&q=$1 [L]

Exemplo 2: Listas de traduções

A questão de usar uma única variável que receberá o valor da url, funciona melhor para este segundo caso:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f [OR]
RewriteCond %{REQUEST_FILENAME} !-s [OR]
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L,NC]

Imagine que seu cliente queira criar páginas novas, de ‘política de privacidade’, ’sobre a empresa’, seja lá qual for o assunto da página. Ele vai querer acessá-la de forma rápida e acessível. Para tanto, index.php?area=view_page&page=4354 não parece agradar muita gente. Não seria interessante deixar que o próprio cliente crie seu padrão de URL? Talvez /politicas ou /empresa.

Existe uma forma interessante de se fazer isso: usando uma lista de expressões regulares e seus arquivos originais, os quais serão usados caso as expressões regulares casarem. Por exemplo, nos casos acima, apenas com o código abaixo no .htaccess, já poderíamos fazer algo:

A idéia é usar a REQUEST_URI (no php $_SERVER['REQUEST_URI']). Ela retornará, por exemplo, /ler/minha_noticia_bombastica que casará com ^/ler/([a-z0-9_-])$ e por consequência, irá chamar a noticias.php. Agora, como pegar o ‘minha_noticia_bombastica’ ? Fácil! Basta apenas utilizarmos os grupos das expressões regulares de forma apropriada. Usando o exemplo do php, com preg_match podemos resolver isso!

$urlPatterns = Array(
	'/^ler\/([a-z0-9_-]+)$/i' => 'noticias.php'
);
foreach ($urlPatterns as $pattern => $fileName)
	if (preg_match($pattern, $_SERVER['REQUEST_URI'], $vars)) {
		$_GET = $vars;
		include $fileName;
		break;
	}
}

Pronto! Alguns usuários podem ter notado, mas $vars irá ser uma sequência numérica dos grupos casados:

0 => /ler/minha_noticia_bombastica, 1 => ‘minha_noticia_bombastica’

Para resolver isso, podemos dar nomes aos grupos, o que seria extremamente normal para o programador (que utilizaria a variável $_GET normalmente) e bonito aos olhos do cliente. Para tanto, modificamos a nossa $urlPatterns:

	$urlPatterns = Array(
		'/ler\/(?<news -slug>[a-z0-9_-]+)$/i' => 'noticias.php'
	);</news>

Assim, poderemos acessar $_GET['news-slug']. Como fica mais difícil do usuário modificar nomes de variáveis vindos da URL, se torna uma solução segura. Podemos ter certeza de que $_GET['news-slug'] não conterá aspas, caracateres hexadecimais ou qualquer outro tipo de código malicioso. Pois se tivesse, não passaria no teste da expressão regular. E também nos certificamos de que aquele arquivo (noticias.php) só esteja sendo acessado, caso nossa index.php o esteja incluindo. Porque o usuário não conseguirá acessar de fora.

Neste caso, nós estipulamos os valores na $urlPatterns, mas ainda se pode pegar esses valores do banco de dados, por exemplo. Uma lista de ‘tradução’ para a url. Funciona muito bem, principalmente com páginas estáticas ou fixas. Ao invés do cidadão digitar index.php?area=pages&page_id=4232, ele estará acessando /sobre-a-empresa. Para usuários provenientes de sites de busca, isto é muito importante. Lhe dá muito mais segurança e você garante o seu clique. Ele vai direto ao ponto.

Decorator Pattern

É um pattern desenvolvido para modificar um determinado objeto (seja modificar alguma coisa já existente ou delegar uma nova responsabilidade) sem a necessidade de extendê-lo. O que é muito bom, assim, o reaproveitamento de código é maior ainda! Enfim, vou tentar dar uma explicada no pattern:

Diagrama de Classes do Decorator Pattern

Abaixo segue o código usado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

class Message {
 
	protected $msg;
 
	public function __construct($msg) {
		$this->setMsg($msg);
	}
 
	public function getMsg() {
		return $this->msg;
	}
 
	public function setMsg($msg) {
		$this->msg = $msg;
	}
 
	public function __toString() {
		return $this->getMsg();
	}
 
}
 
class Success_Message extends Message {
	public function __construct($msg) {
		parent::__construct($msg);
		$msg = new DivClass_Decorator(
			new Li_Decorator(
				$this
			)
			,'success-msg');
		$this->setMsg((String)$msg);
	}
}
 
class Error_Message extends Message {
 
	public function __construct($msg) {
		parent::__construct($msg);
		$newmsg = new DivClass_Decorator(
			new Li_Decorator(
				$this
			)
			,'error-msg');
		$this->setMsg((String)$newmsg);
	}
 
}
 
interface Msg_Decorator_Interface {
	function render(Message $message);
}
 
abstract class Msg_Decorator_Abstract extends Message {
 
	public function __construct(Message $msg) {
		$this->render($msg);
	}
 
}
 
class Li_Decorator extends Msg_Decorator_Abstract implements Msg_Decorator_Interface {
 
	public function render(Message $message) {
		$msg = $message->getMsg();
		$this->setMsg('<ul><li>'. $msg .'</li></ul>');
	}
 
}
 
class Div_Decorator extends Msg_Decorator_Abstract implements Msg_Decorator_Interface {
 
	public function render(Message $message) {
		$this->setMsg('<div>'. $message->getMsg() .'</div>');
	}
 
}
 
class DivClass_Decorator extends Msg_Decorator_Abstract implements Msg_Decorator_Interface {
 
	private $class;
 
	public function __construct(Message $msg, $class = null) {
		$this->class = $class;
		parent::__construct($msg);
	}
 
	public function render(Message $message) {
		$this->setMsg('<div class="'.(null === $this->class?'default-class':$this->class).'">'.$message->getMsg().'</div>');
	}
 
}

OK! Com o código em mãos, vamos pensar um pouquinho. Tenho uma cacetada de classes, todas fazendo praticamente a mesma coisa. E agora? Calma, Juvenal. Vamos analizar:

1. Temos a classe Mensagem. Sabemos que ele representa uma mensagem. Métodos básicos para manipularmos a mensagem e um __toString() que irá retornar o valor em string pra classe quando for feito o cast.
2. Classe Msg_Decorator_Abstract que extende da classe Mensagem. Todos os nossos decoradores, por assim dizer, irão ser filhos desta classe. O exemplo é tão simples que a classe abstrata nem tem métodos abstratos. Mas a idéia é que tenha, caso necessário.
3. Msg_Decorator_Interface, essa interface obriga os programadores que quiserem criar decorators a escrever o método render(). Que é chamado pela nossa classe Abstract no construtor.
4. Li_Decorator, Div_Decorator e DivClass_Decorator são exemplos de decorators.

Vamos ver o negócio funcionando? Vamos escrever o seguinte código:

1
2
3
4
5

   	print new Div_Decorator(
			new Li_Decorator(
				new Message("Mensagem de teste!")
			)
		);

Irá imprimir

1
2
3
4
5

<div>
<ul>
	<li>Mensagem de teste!</li>
</ul>
</div>

Viram? Simples e prático! Claro que o exemplo é bem simples e talvez nem seja tão útil. Mas é só pensar um pouquinho mais que logo surgem exemplos onde se usar o Decorator.

Entender agora fica mais fácil. Apenas comece olhando do meio para a esquerda. Primeiro nós instanciamos a classe Message com o mensagem “Mensagem de teste!”. O método getMsg() retornará exatamente isso: “Mensagem de teste!”. Porém, no momento em que é instanciado o Li_Decorator, ele vai mudar a mensagem usando o método render(), que deve ser implementado na Msg_Decorator_Interface e chamado na Msg_Decorator_Abstract pelo construtor. E assim acontece com o Div_Decorator.

Notem que eu decidi mudar o valor da mensagem usando o setMsg. Eu já li em alguns lugares onde fica armazenada a instância da classe anterior e então o método getMsg seria chamado em forma de cascata, fazendo com que a mensagem original nunca fosse alterada de verdade, e no fim ela é, igual a um método recursivo, retornada decorada e maquiada.

Reutilizando o código

Bom, como eu havia dito no começo, o Observer Pattern nos possibilita o reuso. O exemplo são aquelas duas classes das quais eu não cheguei a falar: Error_Message e Success_Message.

Observem que são simples e, utilizando os Decorators já existentes, mostram uma mensagem personalizada de Erro e de Sucesso! Para utilizá-las, basta usar:

1
2

print new Error_Message("Erro! Você fez algo errado!");
print new Success_Message("Sucesso! Parabéns!");

O que imprimirá:

1
2
3
4
5
6
7
8
9
10

<div class="error-msg">
<ul>
	<li>Error!</li>
</ul>
</div>
<div class="success-msg">
<ul>
	<li>Sucesso! Parabéns!</li>
</ul>
</div>

Prós

• Adiciona flexibilidade ao código.
• Facilmente reutilizada.
• Ótimo para sistemas que possibilitam o uso de plugins.

Contras

• Gera um grande número de arquivos (se for pensar que cada arquivo é uma classe ou vice-versa).
• Dependendo da quantidade de classes aloca muita memória.
• Ruim para sistemas mais fechados e bitolados ou muito padronizados.

Acho que é isto pessoal. O que acharam? Não é um bixo de sete cabeças, né?

Os poucos que já me conhecem, sabem que sou fã do GVim. Nem Vi nem Vim. Sempre escuto pessoas falando de outros editores, como o bluefish, notepad++, emacs. Mas, eu sou cabeça-dura, ranzinza mesmo. Então vou fazer um série de posts mostrando umas coisas divertidas de se fazer usando o GVim para facilitar a vida e acelerar o desenvolvimento. São coisas pequenas mas, que às vezes, consomem um bom tempo e enchem o saco.

Começando por criar uma SQL de INSERT numa tabela que tenha muitas colunas. No exemplo abaixo, vou usar o PHP e MySQL para fazer, porém, é só adaptar pra outras linguagens.

Bom, vamos começar do começo:

Listando as colunas.

Vamos imaginar uma tabela do banco de dados que tenha muitas colunas. Como exemplo, vou usar uma própria do wordpress, que é responsável pelo armazenamento dos posts. A idéia do post não é ensinar expressão regular, mas sim mostrar como utilizá-la no GVim e mostrar o seu real poder.

Criando à partir do terminal:

Bom, tudo começa no conhecido terminal. Digitamos:

# mysql -uUSER -pSENHA DATABASE -e “describe TABLE;” #No meu caso usei a tabela de posts wordpress

+-----------------------+---------------------+------+-----+---------------------+----------------+
| Field                 | Type                | Null | Key | Default             | Extra          |
+-----------------------+---------------------+------+-----+---------------------+----------------+
| ID                    | bigint(20) unsigned | NO   | PRI | NULL                | auto_increment |
| post_author           | bigint(20)          | NO   |     | 0                   |                |
| post_date             | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_date_gmt         | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_content          | longtext            | NO   |     | NULL                |                |
| post_title            | text                | NO   |     | NULL                |                |
| post_category         | int(4)              | NO   |     | 0                   |                |
| post_excerpt          | text                | NO   |     | NULL                |                |
| post_status           | varchar(20)         | NO   |     | publish             |                |
| comment_status        | varchar(20)         | NO   |     | open                |                |
| ping_status           | varchar(20)         | NO   |     | open                |                |
| post_password         | varchar(20)         | NO   |     |                     |                |
| post_name             | varchar(200)        | NO   | MUL |                     |                |
| to_ping               | text                | NO   |     | NULL                |                |
| pinged                | text                | NO   |     | NULL                |                |
| post_modified         | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_modified_gmt     | datetime            | NO   |     | 0000-00-00 00:00:00 |                |
| post_content_filtered | text                | NO   |     | NULL                |                |
| post_parent           | bigint(20)          | NO   | MUL | 0                   |                |
| guid                  | varchar(255)        | NO   |     |                     |                |
| menu_order            | int(11)             | NO   |     | 0                   |                |
| post_type             | varchar(20)         | NO   | MUL | post                |                |
| post_mime_type        | varchar(100)        | NO   |     |                     |                |
| comment_count         | bigint(20)          | NO   |     | 0                   |                |
+-----------------------+---------------------+------+-----+---------------------+----------------+

Deve aparecer algo parecido com isso para você. Bom, para facilitar, apagamos manualmente as 3 primeras linhas e a última. Ou, se quiser fazer pelo gvim digitando:

:1,3g/^./d
:$g/^./d

Bom, o comando g, vai fazer um busca e, logo após, executa um comando. No nosso caso as três primeiras linhas que contenham pelo menos 1 caracter e a última linha do arquivo.

Jogando o lixo no lixo

:%s/^|\s*\([^ ]*\).*/\1/g

Você obterá algo assim:

ID
post_author
post_date
post_date_gmt
post_content
post_title
post_category
post_excerpt
post_status
comment_status
ping_status
post_password
post_name
to_ping
pinged
post_modified
post_modified_gmt
post_content_filtered
post_parent
guid
menu_order
post_type
post_mime_type
comment_count

“It’s like magic!” Wow. Sim. Usamos o %s, que substitui no arquivo inteiro. Notem que é necessário escapar os parênteses para criar grupos em expressão regular. Isso é devido a utilidade do GVim. Em um editor cuja finalidade é facilitar a vida na programação, não teria sentido ao contrário. Afinal, procurar por um if ( ou um while () é muito comum. E ter que ficar escapando tudo, ia ser um saco! Bom, uma explicação melhor:

• %s -> substitui em todo arquivo.
• /^|\s*\([^ ]*\).*/ -> Começa com | pode ter espaços (captura tudo que não for espaços) o resto da linha que não nos interessa.
• \1/g -> \1 Faz uma referência ao primeiro grupo capturado na expressão anterior, no caso (tudo que não for espaço). O g é para que pudesse casar mais de uma vez. Neste caso não é necessário (força do hábito).

Notem que é necessário aquele .* do final, pois a expressão que casar, é a expressão substituída. E não somente o que estiver entre os grupos. Colocando o que queremos manter no grupo (no caso o nome da coluna) e substituimos a linha inteira pelo nome da coluna.

Juntando numa única linha

Bom, agora é simples! Para montarmos a SQL precisamos juntar elas em 1 linha só. Para isso, olhamos o número de linhas que tem no arquivo e, no modo normal, com o ponteiro na primeira coluna da primeira linha (pra ter certeza pode ser digitado gg), digitamos:

(NUMERO_DE_LINHAS)J – Por exemplo: O arquivo tem 24 linhas, então será digitado: 24J. Tendo elas em uma só linha, basta substituir os espaços por vírgula:

%s/\s/, /g

Colocar o digitado entre parênteses e depois digitar: yypp. Agora temos duas linhas iguais, assim:

(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)
(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)
(ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count)

Dando forma

Bom, digitamos manualmente INSERT INTO e VALUES, no começo da primeira linha e ao final, respectivamente.

Na linha de baixo, vamos utilizar uma coisinha legal:

:2s/\([^,]*\)[,]?/'%s', /g

O que acaba na seguinte transformação linha 2:

'%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s',

Basta ajustar os detalhes, parênteses e vírgulas a mais! (Poderia ser feito um grupo na vírgula, pra se caso ela existir, colocar, e não por, caso contrário. Mas eu achei muita frescura) E agora o toque final:

:3s/\([^,()]*\)[,]?/addslashes($_POST['\1']), /g

O que retorna:

addslashes($_POST['(ID']), addslashes($_POST['post_author']), addslashes($_POST['post_date']), addslashes($_POST['post_date_gmt']), addslashes($_POST['post_content']), addslashes($_POST['post_title']), addslashes($_POST['post_category']), addslashes($_POST['post_excerpt']), addslashes($_POST['post_status']), addslashes($_POST['comment_status']), addslashes($_POST['ping_status']), addslashes($_POST['post_password']), addslashes($_POST['post_name']), addslashes($_POST['to_ping']), addslashes($_POST['pinged']), addslashes($_POST['post_modified']), addslashes($_POST['post_modified_gmt']), addslashes($_POST['post_content_filtered']), addslashes($_POST['post_parent']), addslashes($_POST['guid']), addslashes($_POST['menu_order']), addslashes($_POST['post_type']), addslashes($_POST['post_mime_type']), addslashes($_POST['comment_count)']),

E, para concluir tudo, colocamos dentro de um sprintf, tudo termina assim:

$insertSQL = sprintf("INSERT INTO (ID, post_author, post_date, post_date_gmt, post_content, post_title, post_category, post_excerpt, post_status, comment_status, ping_status, post_password, post_name, to_ping, pinged, post_modified, post_modified_gmt, post_content_filtered, post_parent, guid, menu_order, post_type, post_mime_type, comment_count) VALUES (
'%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s'
)",addslashes($_POST['ID']), addslashes($_POST['post_author']), addslashes($_POST['post_date']), addslashes($_POST['post_date_gmt']), addslashes($_POST['post_content']), addslashes($_POST['post_title']), addslashes($_POST['post_category']), addslashes($_POST['post_excerpt']), addslashes($_POST['post_status']), addslashes($_POST['comment_status']), addslashes($_POST['ping_status']), addslashes($_POST['post_password']), addslashes($_POST['post_name']), addslashes($_POST['to_ping']), addslashes($_POST['pinged']), addslashes($_POST['post_modified']), addslashes($_POST['post_modified_gmt']), addslashes($_POST['post_content_filtered']), addslashes($_POST['post_parent']), addslashes($_POST['guid']), addslashes($_POST['menu_order']), addslashes($_POST['post_type']), addslashes($_POST['post_mime_type']), addslashes($_POST['comment_count']));

Ah, vamos, não foi tão difícil nem demorado! Garanto que você perderia mais tempo tendo que fazer isso manualmente!

Copiando do phpMyAdmin:

Bom, para aqueles que trabalham com o phpMyAdmin, basta ir na tabela deseja e, da aba Estrutura, copiar a tabela para o GVim, vai ficar algo mais ou menos assim:

ID  	bigint(20)  	 	UNSIGNED  	Não  	 	auto_increment  	  Navegador distingue valores   	  Alterar   	  Eliminar   	  Primária   	  Único   	  Índice   	 Texto completo
	post_author 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_date 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_date_gmt 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_content 	longtext 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_title 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_category 	int(4) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_excerpt 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_status 	varchar(20) 	utf8_general_ci 		Não 	publish 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	comment_status 	varchar(20) 	utf8_general_ci 		Não 	open 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	ping_status 	varchar(20) 	utf8_general_ci 		Não 	open 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_password 	varchar(20) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_name 	varchar(200) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	to_ping 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	pinged 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_modified 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_modified_gmt 	datetime 			Não 	0000-00-00 00:00:00 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_content_filtered 	text 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_parent 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	guid 	varchar(255) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	menu_order 	int(11) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_type 	varchar(20) 	utf8_general_ci 		Não 	post 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	post_mime_type 	varchar(100) 	utf8_general_ci 		Não 			Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo
	comment_count 	bigint(20) 			Não 	0 		Navegador distingue valores 	Alterar 	Eliminar 	Primária 	Único 	Índice 	Texto completo

Vamos remover o que não nos é necessário e pegar somente a primeira coluna dessa tabela separada por tabs, digitando no GVim:

:%s/\s*\([^ \t]*\).*/\1/g

Bom, conseguimos o que queríamos. Uma coluna em cada linha. Agora é só concluir como descrito acima, onde os dados provém do terminal. o/

Conclusão

Idéias, sugestões, receitas de bolos e muito mais, vocês podem me mandar por e-mail ou comentar abaixo!
E lembrem-se: mais dicas de coisas que podem ser feitas no GVim estão por vir!