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?

• Certeza de encontrar todas as incidências
• Ficam visualmente destacadas (com :set hlsearch)
• Testar substituições
• Verificar a ortografia atrás de erros de digitação
• Encontrar variáveis ou funções não utilizadas, só declaradas
• Encontrar rapidamente algum termo
• Verificar a existência de algum termo

Além da conhecida / (barra) para buscar, existe o :vimgrep. É dele que quero falar.

Vimgrep

Comando

:vim[grep][!] /{pattern}/[g][j] {files}

• Busca inscidências de pattern nos files listados.
• pattern pode ser uma expressão regular ou não
• A exclamação (!) ignora as alterações já feita no arquivo atual
• g procura por todas as inscidências, não só a primeira, em cada arquivo
• j pula para o primeiro resultado ao executar o comando
• files podem conter wildcards, como *, ? e **
• Os resultados são abertos na quickfix list

Exemplos

:vimgrep! /$var/ arquivo.pl

Pesquisa pela primeira inscidência de $var no arquivo.pl

:vimgrep /texto/ *.rb

Busca por texto em todos os arquivos com a extensão .rb do diretório atual (para descobrir qual o diretório atual, use :pwd. Para mudar :cd dir)

:vimgrep /TeXtO/ *.py dir/*.py

Busca com case-sensitive em todos os arquivos .py do diretório atual e dos dentro do diretório dir/.

:vimgrep /minhaFuncao/g **/*.c

Busca recursiva dentro da árvore de diretórios do diretório atual cuja extensão seja .c

:vimgrep /< \([^ ]\+\)[^>]*>.\+< \/\1>/ index.html

Busca usando expressões regulares também são permitidas!

Navegando na QuickFix List

• :copen
• :cfirst
• :cprevious
• :cnext
• :clast
• :cclose

Como nosso foco é a eficiência, podemos criar mapeamentos para andar pela quickfix list!

map <F9> :copen<CR>
map <F10> :cclose<CR>
map <A-j> :cnext<CR>
map <A-k> :cprevious<CR>

Exemplo de uso do vimgrep

Conclusão

Esse recurso não parece ser muito abordado por ai, mas é extremamente importante. Seja criativo e descubra onde melhor usar o :vimgrep! Tenho certeza de que vai lhe ajudar! E quando encontrar, comente ai!

Eu gosto dessa tradução, porque traduz bem direitinho o que ele representa, é uma fachada para “esconder” chamadas de vários métodos de objetos diferentes atrás de um mesmo método. Pense assim:

Toda vez que eu aperto o botão de uma máquina de café e pedir um mocacchino, acontece a mesma coisa:

• Moe-se o café
• Pega-se um copo
• Esquenta-se a água
• Passa-se o café
• Coloca-se o café passado no copo
• Coloca-se o chocolate
• Coloca-se o leite
• Apita pra dizer que está pronto

Se olharmos isso com a visão de um pojetista, vemos que temos várias responsabilidades e que não podemos deixar tudo numa mesma classe, como por exemplo:

• Responsável por moer o café
• Responsável por colocar algo no copo
• Responsável por pegar 1 copo novo
• Responsabilidade de saber quanto de cada ingrediente por no copo
• Responsabilidade de apitar e escrever nos leds

Enfim, para que o código seja organizado, precisamos distribuir as responsabilidades de acordo com as necessidades e obrigações de cada classe. Porém, cada vez que o botão for pressionado, seria muito cruel ter que chamar várias classes e executar esses métodos que selecionam o copo, moem o grão, etc.

Para esses casos foi pensando o Facade Pattern, ou seja, a Fachada. Todo aquele algoritmo descrito na primeira lista acima, é encapsulado dentro de uma classe específica para a máquina de café, dentro do método pressionaBotao, por exemplo. Chamando o método, ele se encarrega de interagir com os objetos de seleção do copo, do cálculo da quantidade de ingredientes, etc.

Fiz um exemplo em perl, pensando num cinema. Acredito que fique fácil entender a partir dele. Seguem as classes utilizadas:

#!/usr/bin/perl -w
{
	# Classe representando o amplificador
	package Amplifier;
	# construtor
	sub new {
		my $class = shift;
		$class = ref($class) || $class;
		my $this = {};
		bless($this, $class);
		return $this;
	}
	# liga o amplificador
	sub on {
		my $this = shift;
		print "Turning the Amplifier [ON]\n";
	}
	# desliga o amplificador
	sub off {
		my $this = shift;
		print "Turning the Amplifier [OFF]\n";
	}
	# Muda o volume
	sub setVolume {
		my $this = shift;
		$volume = shift;
		print printf "Turning the Amplifiers volume to %d%%\n", $volume;
	}
	# coloca no mudo
	sub mute {
		my $this = shift;
		$this->setVolume(0);
	}
}
 
{
	# Classe representado o aparelho de DVD
	package Dvd;
	# construtor
	sub new {
		my $class = shift;
		$class = ref($class) || $class;
		my $this = {};
		$this->{state} = 'stop';
		$this->{movie} = undef;
		bless($this, $class);
		return $this;
	}
	# liga o dvd
	sub on {
		my $this = shift;
		print "Turning the DVD Player [ON]\n";
	}
	# desliga o dvd
	sub off {
		my $this = shift;
		print "Turning the DVD Player [OFF]\n";
	}
	# da play no filme
	sub play {
		my $this = shift;
		$movie = shift;
		if ($this->{state} eq 'play') {
			$this->{stop}();
			$this->{play}($movie);
		} else {
			$this->{movie} = $movie;
			$this->{state} = 'play';
			print printf "Playing the movie %s\n", $movie
		}
	}
	# da stop no filme
	sub stop {
		my $this = shift;
		if ($this->{state} eq 'play') {
			$this->{state} = 'stop';
			print printf "Stoping the movie %s\n", $this->{movie};
			$this->{movie} = undef;
		}
	}
	# ejeta a bandeja pra por no dvd
	sub eject {
		my $this = shift;
		if ($this->{state} eq 'play') {
			$this->{stop}();
		}
		print "Ejecting the DVD\n";
	}
}
{
	# classe representando o projetor
	package Projector;
	# construtor
	sub new {
		my $class = shift;
		$class = ref($class) || $class;
		my $this = {};
		bless($this, $class);
		return $this;
	}
	# ajusta o canal de vídeo
	sub videoChannel {
		my $this = shift;
		print "Setting Video Channel\n";
	}
	# liga o projetor
	sub on {
		my $this = shift;
		print "Turning the Project [ON]\n";
	}
	# desliga o projetor
	sub off {
		my $this = shift;
		print "Turning the Project [OFF]\n";
	}
}
{
	# Classe representando as luzes do cinema
	package Lights;
	# construtor
	sub new {
		my $class = shift;
		$class = ref($class) || $class;
		my $this = {};
		$this->{state} = 'off';
		bless($this, $class);
		return $this;
	}
	# liga as lâmpadas
	sub on {
		my $this = shift;
		if ($this->{state} eq 'off') {
			print "Turning the Lights [ON]\n";
			$this->{state} = 'on';
		}
	}
	# desliga as lâmpadas
	sub off {
		my $this = shift;
		if ($this->{state} eq 'on') {
			$this->{state} = 'off';
			print "Turning the Lights [OFF]\n";
		}
	}
}
{
	# classe representando uma máquina de pipoca
	package PopcornMachine;
	# construtor
	sub new {
		my $this = {};
		my $class = shift;
		$class = ref($class) || $class;
		$this->{state} = 'off';
		bless($this, $class);
		return $this;
	}
	# liga a máquina
	sub on {
		my $this = shift;
		if ($this->{state} eq 'off') {
			$this->{state} = 'on';
			print "Turning the Popcorn Machine [ON]\n";
		}
	}
	# estoura as pipocas
	sub pop {
		my $this = shift;
		if ($this->{state} eq 'on') {
			print "Poping the corns ;P\n";
		}
	}
	# desliga a máquina
	sub off {
		my $this = shift;
		if ($this->{state} eq 'on') {
			$this->{state} = 'off';
			print "Turning the Popcorn Machine [OFF]\n";
		}
	}
}

A orientação a objetos no perl é meio sinistra. Existem diversas formas de se programar orientado a objetos no perl, eu escolhi esta pois parece mais simples e fácil. Bom, essas são as classes utilizadas:

• Amplifier
• DVD
• Projector
• Lights
• PopcornMachine

Bom, cada vez que um filme inicia ou termina no cinema, várias operações são repetidas sempre. Alguém já viu cinema com as luzes acesas? Bem, sempre se desliga as luzes. Então observe a classe abaixo que representa o Facade.

{
	# classe representando o cinema
	package CineFacade;
	# construtor
	sub new {
		my $this = {};
		my $class = shift;
		$class = ref($class) || $class;
		$this->{amplifier} = shift || undef;
		$this->{dvd} = shift || undef;
		$this->{projector} = shift || undef;
		$this->{lights} = shift || undef;
		$this->{popcornMachine} = shift || undef;
		bless ($this, $class);
		return $this;
	}
	# começa a ver o filme
	sub watchMovie {
		my $this = shift;
		$movie = shift;
		# Popcorn machine
		$this->{popcornMachine}->on();
		$this->{popcornMachine}->pop();
		# Home lights
		$this->{lights}->off();
		# Projector
		$this->{projector}->on();
		$this->{projector}->videoChannel();
		# Amplifier
		$this->{amplifier}->on();
		$this->{amplifier}->setVolume(100);
		# DVD
		$this->{dvd}->on();
		$this->{dvd}->play($movie);
	}
	# termina de ver o filme
	sub endMovie {
		my $this = shift;
 
		$this->{popcornMachine}->off();
		$this->{lights}->on();
		$this->{projector}->off();
		$this->{amplifier}->off();
		$this->{dvd}->stop();
		$this->{dvd}->eject();
		$this->{dvd}->off();
	}
}

Observem o método watchMovie e endMovie. Eles chamam operações comum a todas as seções do cinema.
Aqui vai o exemplo de uso do facade no meio da aplicação:

{
	# Exemplo de uso
	$cine = CineFacade->new(
			Amplifier->new(),
			Dvd->new(),
			Projector->new(),
			Lights->new(),
			PopcornMachine->new()
			);
 
	print "Movie Session started: \n\n";
	$cine->watchMovie('Titanic');
 
	print "Movie Session ended: \n\n";
	$cine->endMovie();
}

O output é mais ou menos assim:

Movie Session started: 
 
Turning the Popcorn Machine [ON]
Poping the corns ;P
Turning the Project [ON]
Setting Video Channel
Turning the Amplifier [ON]
Turning the Amplifiers volume to 100%
Turning the DVD Player [ON]
Playing the movie Titanic
 
Movie Session ended: 
 
Turning the Popcorn Machine [OFF]
Turning the Lights [ON]
Turning the Project [OFF]
Turning the Amplifier [OFF]
Stoping the movie Titanic
Ejecting the DVD

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.

Patterns de URLS

A primeira coisa a se pensar ao usar Clean URL’s é a modularização, estruturação ou hierarquisação dos conteúdos do site, para que se possa fazer algo interessante. Precisamos de algo único e que seja facilmente localizável. Afinal, um dos motivos do uso de Clean URL é este: que o conteúdo daquela página seja facilmente localizável (isso inclui memória do usuário, assimilação e, por que não, associação com outros assuntos. Além é claro de convenções, tais como: /about, /contact, etc).

Para blog, é muito interessante que o título de um post vire parte da URL. Ao ver o link, o usuário já sabe sobre o que se trata e o que vai encontrar neste post. Logo, se o vizinho da sua tia puser um link de um post seu no blog dele, torna-se muito mais fácil alguém clicá-lo. Nem sempre o link para o post conterá o título, talvez o link seja um mero ‘clique aqui’. Mas, passando o mouse sobre o link, o usuário vai ler o título do post. Para por o título na URL, existe um termo técnico chamado SLUG, que contém apenas letras, números, hífens e underlines. Por exemplo: ‘/artigo/como-usar-mod_rewrite’ é muito mais prático e óbvio do que um ‘?categoria=article&article_id=5433′.

Para buscadores isso é muito importante também. Note a diferença entre as URL’s do exemplo anterior: para usuários que não tem uma intimidade com Web, ver descrito o nome do título lhe dá muito mais segurança de clicar. Pessoas menos íntimas costumam julgar a periculosidade de uma URL pelo que consta nela. Constando “coisas do diabo” como ‘?id=343&vid=3fdd&hash=54dfsg===v3rgf’ devem ser exorcizadas!

Hierarquisando

Hierarquisar o site, fazer a topologia, mapa do site. Vários termos! Mas para mim, são a mesma coisa. No momento em que refletimos aquelas velhas questões clássicas antes de montar um site:

• Qual o público alvo ?
• Qual o objetivo ?
• O que é preciso ?

Já estamos montando mentalmente uma organização. Vamos pensar no blog deste que vos escreve e responder às perguntas.

Preciso de um blog. Onde eu escrevo posts sobre assuntos que me venham à cabeça para compartilhar um pouco da experiência que tenho e obtive lendo outros blogs, de pessoas que liam outros blogs. Ou seja, quero retribuir o que recebi (está aí o objetivo). Meu público alvo? Justamente aqueles que procuram por informações. Que programam, aprendem e crescem porque são apaixonados por tecnologias.

Agora vamos organizar essas informações:

No blog, além de posts (o que é totalmente indispensável), também deverá haver categorias, tags, etc. Pois o público alvo é um público sedento por informação. O público quer o máximo de informação possível e de forma rápida e simples. Não há tempo para se perder. Por isso se utiliza a categorização e as tags: fazem com que conteúdos relacionados cheguem muito mais rápido àqueles que as procuram.

Portanto é necessário que se consiga uma URL fácil para pesquisas no blog. Por exemplo: http://gustavodutra.com/categoria/GVim já lista todos os posts da categoria GVim. O que possibilita o ‘Joãozinho’ favoritar a dada URL e, sempre que entrar, irá se deparar com posts da dita categoria.

À partir do momento que você junta informações sobre o site, você consegue estruturá-lo de forma com que fique claro e simples para o usuário onde ele está. E mais importante! Sempre coloca nomes em URL’s que tenham algum sentido lógico com o contéudo. Fazendo o contrário, faz com que o site perca credibilidade, tanto para buscadores como para usuários finais. A palavra chave é ‘contextualização’. Uma URL uma vez contextualizada junto ao seu conteúdo, fica mais visível na internet!

Quais são os ganhos reais

Muitos dos ganhos podem parecer bobos. Mas não são. Com URL’s bem definidas:

• Aumenta-se a segurança do site
• Facilita a manutenção do site
• Despreocupaçao com diretórios e nomes de arquivos
• Facilita a navegação
• Aumenta o pagerank em buscadores
• Pode aumentar o número de visitas/page views

Se você se perguntou ‘Como?’, aguarde o próximo post! Obrigado pela atenção, até mais!

Hoje vou falar sobre dicas (algumas bem simples, mas que fazem diferença) para aumentar a produtividade no GVim/Vim. Algumas delas são plugins, outras vão direto para o ~/.gvimrc!

1. Color Picker
2. Saindo sem estresse
3. Colocando Headers nos arquivos
4. Abrindo arquivos escritos no arquivo
5. Trabalhando com buffers
6. Aprimorando a busca
7. Mudando a fonte
8. Documentando o código
9. Autocomplete de código
10. Rodando comandos do Shell
11. Solução para arquivos chatos de backup
12. Removendo Linhas em Branco
13. Compilando arquivos e analizando erros
14. Mostrando a identação
15. Autorrecarregando nosso .gvimrc

1. Color Picker

Quem trabalha com web, geralmente precisa rapidamente selecionar uma cor em hexadecimal. Geralmente recorremos à sites para isso. Existe um plugin que resolve nossos problemas, você pode baixar ele aqui: http://www.vim.org/scripts/script.php?script_id=927

Para instalar é muito fácil. Baixe o arquivo colorsel.vim do site mencionado acima, jogue para dentro do diretórios de plugins, no meu caso /usr/share/vim/vim71/plugins. Ao reiniciar o gvim, basta digitar

:colorSel

Ele deve aparecer algo como:



Notem, que caso o vim seja aberto pelo terminar, ele dispara um erro, dizendo que o plugin instalado é para uso com interface gráfica. Para resolver isso, na linha 24 do colorsel.vim, que começa com ’stderr’…

Apenas apague esta linha e o erro não é mais mostrado para você!

2. Saindo sem estresse

Muitos devem ficar brabos ao tentar sair do vim e digitar o Q maiúsculo

:Q

Para isso, vamos por no nosso ~/.gvimrc

cab W w
cab Q q
cab Wq wq
cab wQ wq
cab WQ wq

Isso vai fazer com que ao digitar algum comando da segunda coluna, ele deve interpretar como o da terceira, logo se for digitado :Q, ele vai entender :q. Isso nos livras de muitas dores de cabeça!

3. Colocando Headers nos arquivos

Muita gente gosta de identificar o arquivo que está escrevendo ou até mesmo ao documentar arquivos. Às vezes precisa por uma licensa, o autor do arquivo, a hora em que foi escrito. Algumas IDE’s oferecem isso normalmente, o GVim, apesar de não ser uma IDE, também oferece algo parecido. Basta acrescentar estas linhas no .gvimrc, mapeando a tecla F8 (você pode modificar à sua preferência).

map <F8> O/**<CR>
\* Descrição do arquivo<CR>
\* @author Gustavo Dutra <mechamo@gustavodutra.com><cr>
\* @created <esc>:r!date '+\%d/\%m/\%y'<cr>kJA<cr>
\*/

Ao abrir um novo arquivo, basta pressionar F8, ele acrescentará nosso header (que você pode modificar para o que você desejar!).

4. Abrindo arquivos escritos no arquivo

Algumas linguagens não usam ‘import’, porém incluem arquivos dentro de arquivos, o que salva muito a vida do programador. Mas supondo que estamos editando o arquivo X, que inclui o arquivo Y, e precisamos, por alguma eventualidade, editar algo no arquivo Y. Precisamos abrir o arquivo passando todo o caminho até ele. Para isso, facilitar isso, façamos um atalho:

nmap gf :new %:p:h/<cfile><CR>

Basta posicionar o cursor sobre o nome do arquivo, e digitar ‘gf’. Nomeei gf para significar Go to File. Você pode colocar o atalho que desejar! Basta mudar o gf para o que quiseres.

5. Trabalhando com buffers

Eu particularmente não gosto de um monte de instâncias do GVim aberta ao mesmo tempo, muito menos gosto de tabs. Eu gosto mesmo é de buffers. Para isso criei alguns atalhos para navegar entre eles

map <A-1> :b1<cr>
map <A-2> :b2<cr>
map <A-3> :b3<cr>
map <A-4> :b4<cr>
map <A-5> :b5<cr>
map <A-6> :b6<cr>
map <A-7> :b7<cr>
map <A-8> :b8<cr>
map <A-9> :b9<cr>
map <A-0> :b10<cr>
map <S-F1> :b11<cr>
map <S-F2> :b12<cr>
map <S-F3> :b13<cr>
map <S-F4> :b14<cr>
map <S-F5> :b15<cr>
map <S-F6> :b16<cr>
map <S-F7> :b17<cr>
map <S-F8> :b18<cr>
map <S-F9> :b19<cr>
map <S-F10> :b20<cr>
map <S-F11> :b21<cr>
map <S-F12> :b22<cr>
map <C-Q> :bwipeout<cr>
map <F6> :buffers<cr>

Para quem não sabe, para iniciar um buffer, utilizamos :e. Logo, para abrir nosso .gvimrc num buffer diferente, digitamos

:e ~/.gvimrc

À cada buffer aberto, o GVim da um número sequencial começando em 1. Nos mapa descrito ali em cima, ALT+1 até ALT+0 navegam nos 10 primeiros buffers. SHIFT+F1 até SHIFT+F12, navegam do buffer 11 até o 22. CTRL+Q, fecha o buffer (remove da lista) e F6 lista todos os buffers disponíveis com os nomes dos arquivos e seus respectivos números.

6. Aprimorando a busca

Para buscar por algum trecho de texto no gvim, é utilizado a barra (/).

/texto da busca

Adicionando no nosso .gvimrc o seguinte:

set incsearch
set hlsearch

É possível fazer com que à medida em que é digitado, o GVim saliente o texto (highlight), caso encontrado. Para navegar entre os resultados, utilizamos n (próxima ocorrência) ou N (ocorrência anterior). Mas, uma das coisas interessantes é sobreescrever estes comandos desta forma:

nmap n nzz
nmap N Nzz

zz é responsável por por a linha atual no centro da tela. Logo, isto permite que ao encontrar uma próxima ocorrência do texto, o texto ficará no meio da tela.

7. Mudando a fonte

No Vim a fonte utilizada é a do Terminal no qual ele foi executado. No GVim, por ser gráfico, possibilita com que seja modificada a fonte atual.

set guifont=Fonte\ Desejada\ 8

Lembre-se de escapar os espaços. Logo depois do nome da fonte, é colocado o tamanho dela. Se por alguma acaso você ficar em dúvida em qual fonte utilizar, você pode digitar o seguinte no GVim

:set guifont=*

Com isso, ele abrirá o seletor de fontes do seu OS. Basta selecionar o dar OK. Quando feito e fonte for modificada, você pode digitar somente

:set guifont

Ele retornará a sintaxe correta de como usar a fonte e o tamnho da mesma. Então, basta copiar e colar no .gvimrc!

8. Documentando o código

Todos sabem da importância que é documentar os códigos, assim como sabem a chatisse que é! Para nos ajudar com isso, seguem alguns plugins:

• PHPdoc
• Perl
  
• Javadoc

9. Autocomplete de código

Maneira simples de autocompletar o código é usando CTRL+X + CTRL+O, mas isso é difícil de assimilar, logo podemos criar uma funçãozinha para ajudar:

function! CleverTab()
if strpart( getline('.'), 0, col('.')-1 ) =~ '^\s*$'
return "\<Tab>"
else
return "\<C-X>\<C-O>"
endfunction
inoremap <Tab> <C-R>=CleverTab()<CR>
set completeopt=menu,preview

Ao digitar ‘tex<TAB>’ ele vai tentar utilizar o omnicompletition para completar a palavra, que pode ser uma função/variável criada dentro do arquivo ou nativa da linguagem.

10. Rodando comandos do Shell

Quantas vezes você já precisou ordenar algo em ordem alfabética? copiar um arquivo inteiro para o arquivo que está digitando? Para quem domina o shell, isso vai ser muito útil. No nosso .gvimrc vamos por o seguinte:

set shell=/bin/bash

Feito isso, vamos fazer alguns testes. Abra algum no gvim e cole o seguinte:

Banana
Maçã
Amora
Pêra
Batata
Melancia

Agora, vamos à mágica:

Digite o seguinte:

:%!sort

Tcharam! O % diz que é o arquivo inteiro; o ! exige que seja executado no shell. sort é comando do shell. O GVim automaticamente pega o conteúdo do arquivo, executa o comando no shell e substitui pelo resultado! Então, para copiar um arquivo no fim do nosso aberto, podemos utilizar o ‘cat’

:$!cat /meu/arquivo

Observem que eu utilizei $, ele vai começar a colar na última linha do arquivo. É legal, então, sempre ter certeza que esta linha está em branco, para que não haja perda de dados. Você também pode por numa linha específica.

:6!cat /meu/arquivo

Ele vai substituir o texto da linha 6 com o que contiver no arquivo, conservando da linha 1 até a linha 5, e da linha 7 até o fim do arquivo.

11. Solução para arquivos chatos de backup

Sabe aqueles arquivos de backup do vim? Que ficam .ext~ ? Você edita algo no projeto e o vim polui o projeto inteiro, quando você vê, já perdeu as contas de quantos arquivos novos foram criados. Ou até mesmo já commitou aqueles arquivos de swap (.swp) do vim sem querer.

Para resolver isso, podemos mudar o diretório onde eles são criados ou até mesmo desabilitá-los, basta acrescentar no .gvimrc:

set backup
set backupdir=/tmp
set dir=/tmp

Se você deseja desabilitar, utilize ’set nobackup’, caso contrário os arquivos de backup irão para o /tmp, e não mais para o diretório do seu projeto! O mesmo acontece com os .swp, especificado pelo ’set dir’.

12. Removendo Linhas em Branco

Para remover todas as linhas em branco do arquivo (vazias ou que contenham somente espaços) podemos utilizar:

:g/^\s*$/d

13. Compilando arquivos e analizando erros

Para compilar um arquivo, basta especificarmos o compilador. Vamos usar o exemplo do javac.

:compiler javac

Para compilar arquivos em java, abra ele no gvim, execute o comando acima e digite:

:make %

Ele irá compilar com o javac o arquivo atual e mostrar os erros em tempo de compilação. Por mais louco que pareça, há também como fazer isso com o php, por exemplo. Mas ao invés de compilar o código, ele checa a sintaxe.

:compiler php
:make %

Ele irá executar `php -l arquivo.php`, retornando os erros de sintaxes! É bom para testes antes de rodá-lo, evitando erros bobos como o esquecimento de 1 ponto e vírgula, um ponto ao concatenar, etc.

Ah! Caso você desejar, pode modificar o comando do make! Se quiser adicionar mais parâmetros, por exemplo, jogar todos os erros que já teve para um determinado lugar (é legal saber o quanto de erro produzimos, para que, ao programar, tentamos cometer cada vez menos e nunca os mesmos (né? ^__^)):

au FileType php set makeprg=php\ -l\ %\ >>\ /tmp/errors.log

assim, ele modificará somente se o arquivo for interpretado como php. Basta dar um :make que ele joga para o arquivo. No final do dia podemos avaliar nossos erros e ver (olha, preciso melhor em tal aspecto).

14. Mostrando a identação

Quem nunca se perguntou (o que este } está fechando? é este ou aquele if?). Pois é, bater o olho e de cara descobrir é complicado, ainda mais quando o início (if () {) não está na mesma página, digo, não é visível, é preciso rolar pra vê-lo.

set list listchars=tab:»·,trail:·,eol:$

Assim, primeiro habilitamos a exibição deles. Depois substituimos com os valores. Isso fará com que o nossa identação fique visível, e possamos ver (hmm… esse if tem 3 tabs antes, então vai fechar na } que tiver 3 tabs antes também!). O arquivo ficará mais ou menos assim:

»····»····»····if (condicao) {$
»····»····»····»····//codigo$
»····»····»····}$

Assim, o código fica claro. Você se acha no tab e consegue enxergar se há espaços desnecessários no final da linha, pois $ representa o nosso amigo \n.

15. Autorrecarregando nosso .gvimrc

Bom, apresento para vocês o autocmd bufwritepost. Ele é executado depois do arquivo ser salvo. Então ao salvar o arquivo ele executa o(s) comando(s) que seguem ali. Acrescentamos, então, ao nosso gvimrc os seguintes comandos:

autocmd! bufwritepost .gvimrc source %
autocmd! bufwritepost .vimrc source %

Assim, ao salvar .gvimrc ou .vimrc, ele recarregará as configurações automaticamente! Voltando ali na dica 13, podemos fazer isso:

autocmd! bufwritepost *.php make %

Rá! Agora, ao salvar um arquivo .php, ele executa no :make % que manda para /tmp/errors.log! Não é feitiçaria, é tecnologia.

Espero que alguma coisa seja útil para vocês! Fui!

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é?