A camada de modelo (model) geralmente é conhecida pela sua capacidade de abstrair as fontes dos dados, tornando o sistema independente de banco de dados, isto é, independente se é utilizado MySQL, Postgres ou até mesmo arquivos CSV ou XML.

Pelo fato desta camada ser responsável pela manutenção dos dados do sistema, é de extrema importância testá-la. Os testes unitários devem garantir que esta esteja funcionando de acordo, para evitar incosistências.

Vamos criar os testes unitários desde o início, desde a criação das tabelas do banco de dados, passando pelos testes e a criação do model em si.

Vamos criar no banco de dados, que já suponho estar configurado no CakePHP, a tabela com a qual vamos trabalhar. Vamos criar um Model simples para produtos.

CREATE TABLE `products` (
   `id` INT(15) UNSIGNED NOT NULL AUTO_INCREMENT,
   `name` VARCHAR(200) NOT NULL,
   `description` TEXT,
   `price` DOUBLE(10,2) UNSIGNED NOT NULL,
   PRIMARY KEY (`id`)
)
comment = 'Produtos'
engine = InnoDB

Tendo esta tabela no banco, podemos utilizar o próprio CakePHP para gerar automaticamente o fixture e o model. Para isto vamos executar o seguinte:

cd meu_projeto/app
../cake/console/cake bake model Product

Interagindo com o Shell do cake, você pode criar seu model de forma simples e prática. Observe que ele criou 2 arquivos:

app/tests/fixtures/product_fixture.php
app/tests/cases/models/product.test.php

Em app/tests/fixtures/product_fixture.php vamos definir nossos dados de teste, os dados que utilizaremos nos testes. Para isto, basta ajustar a propriedade $records:

   public $fields = array(
      'id' => array(
         'type' => 'integer',
         'null' => false,
         'default' => NULL,
         'length' => 15,
         'key' => 'primary'
      ),
      'name' => array(
         'type' => 'string',
         'null' => false,
         'default' => NULL,
         'length' => 200
      ),
      'description' => array(
         'type' => 'text',
         'null' => true,
         'default' => NULL
      ),
      'price' => array(
         'type' => 'float',
         'null' => false,
         'default' => NULL,
         'length' => '10,2'
      ),
      'indexes' => array(
	     'PRIMARY' => array('column' => 'id', 'unique' => 1)
      ),
      'tableParameters' => array(
         'charset' => 'utf8',
         'collate' => 'utf8_general_ci',
         'engine' => 'InnoDB'
      )
   );
   public $records = Array(
      Array(
         'id' => 1,
         'name' => 'Nome do Produto',
         'description' => 'Descrição longa',
         'price' => 15.23
      ),
      Array(
         'id' => 2,
         'name' => 'Nome do Segundo Produto',
         'description' => 'Descrição super longa',
         'price' => 12
      )
   );

Pronto, nosso fixture se encontra com a estrutura da tabela na propriedade $fields e os dados na propriedade $records.

Em app/tests/cases/models/product.test.php ficarão nossos testes. O CakePHP já escreve algumas coisas no arquivo:

public $fixtures = array('app.product');

É essencial que todos os models relacionados devam ter seus fixtures adicionados a esta propriedade, pois senão ele não é capaz de criar as tabelas com os dados de teste.

public function startTest) {
   $this->Product = ClassRegistry::init('Product');
}

Este método é executado sempre antes de cada teste (de ser executado o método que inicia com test). É interessante ter o objeto sempre “reiniciado” ao se fazer cada teste, pois senão um teste pode influenciar no valor do outro. Por exemplo, se o campo name tivesse um índice unique, poderia ter erro caso dois métodos de teste tivessem o mesmo valor sendo inserido, sendo que não era isto que estava sendo testado.

Para ter certeza que o objeto está sendo reinicializado, eu sugiro adicionar (somente necessário nos testes de 1.2.X):

public function endTest() {
   unset($this->Product);
   ClassRegistry::flush();
}

Assim temos mais garantia de que tudo vai funcionar como o esperado.

O teste que o CakePHP 1.2.X insere automaticamente não deixa de ser importante, porém, na versão 1.3.X do CakePHP este teste não é mais inserido automaticamente.

public function testIsA...() {
   $this->asssertIsA($this->Product, 'Product');
}

Quando o ClassRegistry::init() não acha o arquivo com o model sendo inicializado, porém consegue encontrar uma tabela que satisfaça o nome deste model, o CakePHP cria automaticamente um model com a classe GenericModel. Assim, será possível saber se o CakePHP está encontrando o model na estrutura de diretórios.

Bom, a primeira coisa que quero testar neste model, é garantir que não será possível a inserção de dados vazios. Os campos são obrigatórios e devem ser preenchidos com valores não vazios.

public function testNoPassedData() {
   $data = Array()
   $this->assertFalse($this->Product->save($data));
   $error_fields = array_keys($this->Product->validationErrors);
   // Verifica se o campo deu erro na validação
   $this->assertTrue(in_array('name', $error_fields);
   $this->assertTrue(in_array('description', $error_fields);
   $this->assertTrue(in_array('price', $error_fields);
}
public function testEmptyData() {
   $data = Array(
      'name' => '',
      'description' => '',
      'price' => ''
   )
   $this->assertFalse($this->Product->save($data));
   $error_fields = array_keys($this->Product->validationErrors);
   // Verifica se o campo deu erro na validação
   $this->assertTrue(in_array('name', $error_fields);
   $this->assertTrue(in_array('description', $error_fields);
   $this->assertTrue(in_array('price', $error_fields);
}

Bom, o nome e a descrição podem conter o que quiser, desde que contenham alguma coisa. Então, a princípio não há necessidade de mais testes. Mas e o preço do produto?

Bom, vamos pensar no preço: um preço é um valor numérico acima de 0. Então podemos por os seguintes testes:

public function testValidPriceFormat() {
   $valid_prices = Array(3, 5.04, 124.3, 12000, 0.01, 1.0000);
   $data = Array(
      'name' => 'nome válido',
      'description' => 'descrição válida',
      'price' => null // será substituido
   );
   foreach ($valid_prices as $counter => $price) {
      $data['price'] = $price;
      $data['name'] = $data['name'];
      $this->assertTrue($this->Product->save($data));
   }
}
public function testInvalidPriceFormat() {
   $invalid_prices = Array('', -14,0,'zero','1,00', 0);
   $data = Array(
      'name' => 'nome válido',
      'description' => 'descrição válida',
      'price' => null // será substituido
   );
   foreach ($invalid_prices as $price) {
      $data['price'] = $price;
      $this->assertFalse($this->Product->save($data));
      $error_fields = array_keys($this->Product->validationErrors);
      // verifica se está no array de erros
      $this->assertTrue(in_array('price', $error_fields));
   }
}

Vejam que não vale a pena misturar as coisas: quando eu testo valores válidos ou inválidos de preço, somente o preço eu modifico. O restante das informações permancem imutáveis e devem ser válidas. O que queremos testar agora é a validação do preço e não de outras partes.

Uma outra coisa importante é considerar strings e valores com vírgulas para estes casos, são potenciais problemas! Aqui vai uma dica: sempre que trabalhar com campos inteiros, verifique o comportamento do sistema com valores 0 e negativos também!

Bom, temos nossos testes. Precisamos fazer eles passarem. Para isto, vamos adicionar o array de validação ao model.

No arquivo app/tests/cases/model/product.test.php vamos por o seguinte:

public $validate = Array(
   'name' => Array(
      'required' => Array(
         'rule' => '/\S/',
         'message' => 'Deve ser especificado um nome para o produto',
         'required' => true
      )
   ),
   'description' => Array(
      'required' => Array(
         'rule' => '/\S/',
         'message' => 'Deve ser especificado uma descrição para o produto',
         'required' => true
      )
   ),
   'price' => Array(
      'valid' => Array(
         'rule' => array('comparison', '>', 0),
         'message' => 'O preço deve ser maior que zero'
      ),
      'format' => Array(
         'rule' => array('numeric'),
         'message' => 'O preço deve ser um valor numérico válido'
      ),
      'required' => Array(
         'rule' => '/\S/',
         'message' => 'Deve ser especificado um preço para o produto',
         'required' => true
      )
   )
);

Bom, agora é só rodar os testes e ver a barra verde. Simples, huh?

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!

• screen
• ssh
• vim
• skype

Destas, só o skype não é open-source. Mas é interessante manter uma conversa verbal, pois conversas escritas podem desviar o foco da programação, que é bem mais rápida e precisa do que a escrita, que pode deixar brechas para má interpretações. A conversa verbal consegue interromper o programador ao mesmo tempo em que escreve, corrigindo-o ou questionando-o.

Conectados no skype, basta decidir em qual máquina será o desenvolvimento. Esta, por sua vez, terá que ter um servidor ssh. Ela será o host da programação. Será necessário, também, nesta máquina, ter instalado o screen, que é um programa que possibilita criar ’sessões’ no terminal.

Host

screen -S PairProgramming

Parece que nada mudou, mas você está numa sessão do screen chamada PairProgramming.

Precione CTRL+a e digite:

:multiuser on

Pressione CTRL+a novamente e digite:

:acladd usuarioclient

Tudo que você ver nesta sessão, será visto pelo outro usuário (usuarioclient) que se conectará nela.

Então, abra o vim, pois será necessário um edito de textos de verdade , e se divirta:

vim /caminho/arquivo

Client

ssh usuarioclient@host
screen -x usuariohost/PairProgramming

Pronto! Agora você está acessando a mesma seção! Tudo que o usuáriohost fizer, o usuárioclient enxergará e vice-versa.

Agora, basta descutir a tarefa via Skype e programar. As atualizações são em tempo real, ou seja, aparecem ao mesmo tempo que são escritos, digo… depende da conexão, mas não é um grande problema.

Caso seja necessário que o usuarioclient não possa modificar o código, apenas assitir e dar pitacos, o usuáriohost deve pressionar CTRL+A e digitar:

:aclchg usuarioclient -w #

Eu ainda vou programar assim, depois digo a experiência.

Referências

• Linux.com
• Jason Haruska

Quando eu vou escrever em algum programa de qualquer suíte de escritório – openoffice, koffice, etc -, eu geralmente me preocupo mais com o negrito da palavra, com identação do parágrafo do que com o conteúdo em si. Isso é um pecado.

Meu primeiro instinto foi: vou escrever tudo no Vim, depois colo no Impress. Boa! Ok, mas e quanto às páginas?
Vou ter que por página por página? Ainda sim eu teria mais trabalho. Eu teria que refazer as listas para que ficassem com as “bolinhas” à esquerda. E teria que modificar todos os títulos para negrito?

Fui pro google e achei um plugin que já conhecia no resultado: VimOutliner. Ele dita uma sintaxe muito intuitiva para hierarquisar (existe esse verbo?) o conteúdo. Algo assim:

Título do documento
 
Tópico Nível 1
	Tópico Nível 2
	: Parágrafo com alinhamento justify
	; Parágrafo fica do jeito que foi escrito
	- Item de lista
	+ Item de lista numérica

O plugin vem com documentação e um shell script que instala automaticamente o plugin. O site tem toda documentação, é bem simples.

Em http://perens.com/FreeSoftware/Outline/ é possível encontrar vários scripts que convertem o documento para outros formatos. Um deles é o vo2odp.rb, um script em ruby para converter arquivos para o OpenOffice Presentation.

Pra fazê-lo rodar, eu sofri um pouquinho. Tive que instalar o ruby (obviamente) e o rubygems. Depois de instalado:

$ gem install builder
$ gem install rubyzip

Também alterei o script, segue o patch das modificações:

29,30c29,30
< require_gem 'builder'
< require_gem 'rubyzip'
---
> require 'builder'
> require 'zip/zip'

Copie o trecho acima em um arquivo, por exemplo: /tmp/patch_vo2odp, depois execute

$ patch /caminho/para/vo2odp.rb < /tmp/patch_vo2odp

Pronto, agora só escrever sua apresentação. Lembre-se que o plugin tem uma extenção própria, a .otl. Sempre que um arquivo for aberto com esta extenção, o Vim irá carregar o syntax highlight apropriado e algumas outras opções para melhor escrever sua apresentação.

Concluída a apresentação, você pode usar

$ ruby /caminho/para/vo2odp.rb apresentacao.otl apresentacao.odp

Abra com o OpenOffice e salve como .ppt. Pronto! Você acabou de fazer sua apresentação no PowerPoint pelo Vim.

Observações importantes

• O script não quebra as páginas dos slides automaticamente. É separado por capítulos de nível 1. Então, não escreva coisas muito longas dentro de um nível. Lembre-se que é uma apresentação e não um documento de texto.
• Quando aberto no OpenOffice, use o negrito, sublinhado, coloque imagens, etc. Crie seu layout e não pense nisso durante a criação do conteúdo. Escreva antes e formate depois

E isso ai! Gostou? Não? Comente! Dê dicas e sugestões!

E aquela palavra que você sempre escreve errada? Aquela função que você sempre esquece o nome?

Conheça algumas dicas para aumentar a produtividade e diminuir o trabalho dessas coisas rotineiras.

Lista de Abreviaturas

Sabe aquelas palavras que a gente insiste em escrever errado? Principalmente quem trabalha com e-mails, códigos e comentários em outras línguas tem dificuldades com certas palavras. Por exemplo,

vc -> você
q -> que
pq -> porque
nao -> não

Agora a pergunta que não quer calar: Porque não usarmos algo para evitar esse tipo de coisa? Às vezes nem notamos os erros, mas eles estão lá. Mantenha uma lista de abreviaturas no Vim. Cuide dela, adicione novas abreviaturas assim que vierem à sua cabeça. A sintaxe é simples, basta adicionar no seu .vimrc:

"" abbr ERRADO CORRETO, por exemplo:
abbr pq porque
abbr vc você

O Vim ainda possibilita que você crie sintaxes diferentes para arquivos diferentes. Então, seus arquivos .txt podem ter abreviaturas diferentes das de .py. Ou seja, se o nome daquela função python é muito longa ou você insiste em escrevê-la errada, ela merece uma abreviatura, no formato descrito acima (abbr ERRADO CORRETO).

$ mkdir -p ~/.vim/abreviaturas/
$ vim ~/.vim/abreviaturas/txt.vim

Adicione ao txt.vim as abreviaturas utilizadas para arquivos texto. Mesmo que poucas, coloque algumas. Um pouco de disciplina fará com que sua produtividade aumente. Tenha certeza.

Ao seu .vimrc, basta acrescentar:

autocmd BufNewFile,BufRead * source $HOME/.vim/abreviaturas/para_qualquer_linguagem.vim
autocmd BufNewFile,BufRead *.txt source $HOME/.vim/abreviaturas/txt.vim
autocmd BufNewFile,BufRead *.py source $HOME/.vim/abreviaturas/python.vim

O autocmd funciona mais ou menos igual a uma trigger. É um sistema de eventos, basicamente. Ou seja, ao abrir um arquivo novo (BufNewFile) ou um arquivo já existente (BufRead), se o nome do arquivo casar com a expressão (no caso, *, *.txt ou *.py) irá executar o código a seguir.

Vou falar mais sobre o autocmd em outro post, tem muitoooo pano pra manga, hehehe.

Templates de Arquivos

Quando se fala em programação é meio que como na arte. Não só porque programar é uma arte, mas porque nada se cria, tudo se copia. Tudo bem que, hoje em dia, com técnicas de encapsulamento, oop, etc, fica mais difícil. Mas sempre há coisas em comum entre os arquivos. Vamos começar com algo simples.

Template básico para javascript, onde será utilizado jquery.

$(document).onready(function(){
// code here
});

Simples, mas não é um saco ter que escrever isso sempre que abre um arquivo novo? Tome isso como regra: Faça uma, porém apenas uma vez. Não seria mais fácil abrir o arquivo e tcha-ram! Lá está o código que, em 90% dos casos, você irá utilizar?

Esse foi pequeninho, mas imagine um arquivo html. A trabalheira que é copiar todo o caçalho. E se você segue um padrão, pode usar inclusive o css junto. Observe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pt" lang="pt-br" dir="ltr">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<meta http-equiv="Content-Style-Type" content="text/css" />
		<meta name="keywords" content="aqui,vai,as,keywords" />
		<link rel="stylesheet" href="/style.css" />
		<link rel="shortcut icon" href="/favicon.ico" />
        </head>
        <body>
        <div id="wrapper">
                <div id="head"></div>
                <div id="content"></div>
                <div id="footer"></div>
        </div>
</body></html>

E o css:

1
2
3
4
5
6
7
8
9
10
11
12

html * {
}
body {
}
#wrapper {
}
        #wrapper #head {
        }
        #wrapper #content {
        }
        #wrapper #footer {
        }

Imagine um designers, aqueles que fazem o psd e depois passam pra xhtml, tendo que copiar isso vezes e vezes para todos os arquivos que ele faz. Faça apenas uma vez e siga o padrão!

Usuários de django, ao criar um model, precisam escrever sempre os imports ? Se são utilizados sempre, porque não criar um template?

Agora você me pergunta, como carregar o template automagicamente no Vim ? Fácil! Utilizando nosso autocmd =). Do mesmo modo que fizemos com as abreviaturas, vamos criar os diretórios:

$ mkdir -p ~/.vim/templates/

Criei lá os arquivos com os templates que você acha útil.

autocmd BufNewFile *.html 0r ~/.vim/templates/html.tpl
autocmd BufNewFile style.css 0r ~/.vim/templates/cssstyle.tpl
autocmd BufNewFile jquery.*.js 0r ~/.vim/templates/jqueryjs.tpl

Agora, abra seu Vim e sinta a magia:

vim index.html style.css jquery.initscript.js

Executando comandos externos

g(un)zip

O manual do Vim tem um exemplo bem interessante, para abrir arquivos gzipados, editá-los, como se nada tivesse acontecido e salvá-lo no formato gzip de novo. Apesar de que aqui, não precisou acrescentar os códigos abaixo, ele já fez automático. Basta adicionar o .vimrc

augroup gzip
  autocmd!
  autocmd BufReadPre,FileReadPre	*.gz set bin
  autocmd BufReadPost,FileReadPost	*.gz '[,']!gunzip
  autocmd BufReadPost,FileReadPost	*.gz set nobin
  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " . expand("%:r")
  autocmd BufWritePost,FileWritePost	*.gz !mv <afile> </afile><afile>:r
  autocmd BufWritePost,FileWritePost	*.gz !gzip </afile><afile>:r
 
  autocmd FileAppendPre		*.gz !gunzip </afile><afile>
  autocmd FileAppendPre		*.gz !mv </afile><afile>:r </afile><afile>
  autocmd FileAppendPost		*.gz !mv </afile><afile> </afile><afile>:r
  autocmd FileAppendPost		*.gz !gzip </afile><afile>:r
augroup END
</afile>

Verificação por erro

Já deve ter acontecido com você: você salva o arquivo e quando vai testar, faltou um ponto e vírgula, ou escrever o nome de uma função errada, ou algo similar… um erro bobo, mas que não deixou seu código ser executado e exige reparo.

Para ajudar contra esse trabalho desnecessário (teste + correção + teste), que pode se repetir inúmeras vezes, você pode usar o autocmd para alertá-lo, utilizando ferramentas externas. Por exemplo:

autocmd BufWritePost *.pl !perl -c %
autocmd BufWritePost *.php !php -l %
autocmd BufWritePost *.java !javac -Xlint %

Use a criativdade

Utilize sua criatividade e seja mais produtivo na SUA rotina. Deixe as coisas serem automatizadas. Para mais eventos do autocmd, :help autocmd. Tem uma lista bem extensa. Leia a documentação e seja feliz =). Crítias, sugestões e CASES são bem vindos nos comentários =)

Ingredientes

• Lazanha
• Python instalado
• 3 minutos de lazer

Modo de preparo

Pegue os 3 minutos de lazer e utlize para criar um diretório:

$ mkdir ~/htmldocs
$ cd ~/htmldocs
$ echo "<html><head></head><body>Meus posts no blog</body></html>" > index.html
$ python -m SimpleHTTPServer
$ firefox http://localhost:8000

Pronto! Agora você pode gerenciar documentações, fazer preview de posts no seu blog, fazer testes de javascript/css sem precisar instalar o apache ou criar um VirtualHost!

Eu achei útil! E você?

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.

Chega, então, o seu chefe e diz: “Cara, preciso que tu veja algo em outro projeto.” ou até mesmo atualiza seu kernel e precisa rebootar o sistema. Chega sua namorada e pede pra ver o orkut. Seja qual seja o motivo, você precisa fechar o Vim. Mas, mais tarde, vai voltar a mexer, nestes 4 mesmos arquivos. Vai refazer todos os mapeamentos, refazer as marcações, etc.

Pois, se já aconteceu isso com você – comigo acontece muito frequênte -, você pode usar o :mksession.

A sintaxe é a seguinte:

:mksession ~/.vim-sessions/projeto-A.vim

Você escolhe o nome do arquivo e o diretório e o vim grava no arquivo as informações exatas do editor no momento em que foi executado o comando. Dentre as coisas das quais ele grava estão:

1. Mapeamentos de teclas
2. Variáveis globais (iniciadas com maiúsculas e que tenham pelo menos 1 caracter minúsculo)
3. Caso use o GVim, grava o posicionamento e o tamanho dele na tela
4. Todos os arquivos abertos em buffers e o ponteiro do mouse
5. O estado visual do Gvim (folds, marks, incserch)

Depois de gravada, para recarregar a session, basta abrir o arquivo.

gvim -S ~/.vim-sessions/projeto-A.vim
ou
vim -S ~/.vim-sessions/projeto-A.vim

Eu tenho usado bastante para funcionalidades que requerem muita manutenção. Por exemplo, no desenvolvimento web.

vim -S ~/.vim-sessions/projetoA-javascripts.vim
vim -S ~/.vim-sessions/projetoA-accounts.vim

Assim, até o módulo de accounts ficar pronto, testado e aprovado pelo inmetro, todos os arquivos relacionados estão ali. E quando acaba o expediente, sobreescrevo a session, para que no próximo dia eu possa dar continuidade.

E você? Tem alguma idéia melhor? Comente!

Bom, vamos aos requisitos dos quais vamos precisar:

• Pacote ffmpeg instalado (geralmente vem com o mplayer, pode ser instalado por apt-get. Também há uma build no linuxpackages)
• 1 Browser de sua preferência.
• 1 xícara de café puro sem açúcar
• Uma tesoura sem ponta
• Cola em bastão
• 1 url de algum vídeo do youtube

Baixando o vídeo do youtube

Modo de preparo:

1. Abra o browser de sua preferência e acesse a url do vídeo do youtube. Eu vou utilizar: http://www.youtube.com/watch?v=dMR0VRb7g60 uma música dos ‘Os Nerds’ que fala de um cara que pede “me dê op no #seu_coração”, uma paródia com “here comes you’re man”.
2. Após ter carregada a página, abra o código-fonte do mesmo. (Firefox: CTRL+U).
3. Localize no meio de tudo aquilo a string “t”, sim com aspas e tudo “t”. No meu caso ele está nessa linha:

   var swfArgs = {"q": "os%20nerds%20kick%20de%20amor", "vq": null, "sourceid": "ys", "video_id": "dMR0VRb7g60", "l": 164, "sk": "C4c1AWqTMKCqlc-ps6iNq8hHDwAaAkYAU", "fmt_map": "", "usef": 0, "t": "OEgsToPDskJ9NevmQow7fOToemrym1db", "hl": "en", "plid": "AARgxT891VByDIGsAAAAoAAAAAA"};

   Viu ele? “t”: “OEgsToPDskJ9NevmQow7fOToemrym1db”

4. Copie(com a tesoura sem ponta) aquele token (OEgsToPDskJ9NevmQow7fOToemrym1db) da página do seu vídeo
5. Agora, na barra de endereços do browser, vamos trocar um pouco as coisas. o que era:
   http://www.youtube.com/watch?v=dMR0VRb7g60 vai se tornar: http://www.youtube.com/get_video?video_id=dMR0VRb7g60&t=OEgsToPDskJ9NevmQow7fOToemrym1db (Observerem que trocamos: watch por get_video, v por video_id e adicionamos &t=TOKEN), onde depois de &t= colamos com cola bastão o aquele token que retiramos do código-fonte.
6. Dando um enter, ele vai pedir pra fazer o download. Esse download é justamente o flv.
7. Enquanto baixa o vídeo, você toma a 1 xícara de café puro sem açucar.

Convertendo o Vídeo

Bom, nem todo player toca .flv, então talvez alguns queiram convertê-lo pra .mp3 ou pra .avi, .ogg ou .mpeg. Para isso, vamos utilizar o ffmpeg.

Convertendo para mp3

ffmpeg -author "Os nerds" -title "Me dê op" -i download/get_video.flv -ab 128 -ac 2 -acodec mp3 -vn -y ~/"Musicas/Os nerds - Me dê op.mp3"

Voalá! os comandos -author e -title vão mexer na IDv3 da mp3. Assim, quando executar num player, vai aparecer bonitinho o autor e a música. -ab para especificar o bitrate, -i = arquivo de entrada, e -vn = desabilita a gravação de vídeo. -y = é para sobreescrever o arquivo de destino. Ah! e o -acodec para selecionar o codec do audio e -ac o número de canais.

UPDATE
Usando o Arch Linux eu notei que o -acodec mp3 não funcionava. Portanto, caso vocês não conseguirem com -acodec mp3, tentem: -acodec libmp3lame

Convertendo para avi

ffmpeg -i download/get_video.flv -ab 56 -y ~/"Clipes/Os nerds - Me dê op.avi"

Mais parâmetros, ajuda e outras coisas: http://swoolley.org/man.cgi/1/ffmpeg
Agora você não precisa mais aqueles programinhas cheio de spyware ou ver 300 erros antes de conseguir baixar o vídeo pelo vixy.net!

Qualquer dúvida comente!

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!