Jedi Tux

Atualização do PostgreSQL para 9.2 – Arch Linux

Posted in Dicas, Servers by Fernando Basso on 28 de setembro de 2012

----------------------------------------------------
bash-4.2, vaio@nando, Fri Sep 28 07:37:53 
$PWD="~/"  
$ sudo rc.d start postgresql 
[sudo] password for nando: 
:: Starting PostgreSQL

[BUSY] pg_ctl: could not start server
               Examine the lot output

    vim /var/log/postgresql.log

FATAL:   database files are incompatible with server 6009
DETAIL:  The data directory was initialized by PostgreSQL version 9.1, which
is not compatible with this version 9.2.1.

-------------------------------------------------------------------------------
http://www.postgresql.org/docs/current/static/upgrading.html

NOTA: É possível fazer isso com a versão 9.2, mas como no meu caso eu nem consegui
inicializar o postgresql com ela, fiz com a 9.1 mesmo.

    sudo pacman -U /var/cache/pacman/pkg/postgresql-9.1.4-1-i686.pkg.tar.xz


Primeiro de tudo, salvar o banco de dados atual, com a versão 9.1 do postgresql
rodando:

    pg_dumpall > postgresql_backup_completo.sql

Mas aí teve algo errado, pois ele ficava peding a senha do usuário linha após
linha, e com
    pg_dumpall -U postgres ...

aconteceu a mesma coisa.

vim ~/.pgpass
localhost:5432:db_nando:nando:1234

Mas pra fazer o backup de tudo, temos que deixar o campo que especifica
a database com "*":
localhost:5432:*:nando:1234

http://www.postgresql.org/docs/9.2/static/libpq-pgpass.html
On Unix systems, the permissions on .pgpass must disallow any access to world
or group; achieve this by the command chmod 0600 ~/.pgpass. If the permissions
are less strict than this, the file will be ignored. On Microsoft Windows,
it is assumed that the file is stored in a directory that is secure, so no
special permissions check is made.


(08:29)  gciolli: Should ~/.pgpass allow my to just type psql and connect 
                     without any further iteration?
(08:31)  FernandoBasso: .pgpass only takes care of not having to type the 
                     password, all the other options are handled via environment 
                     variables like PGUSER, etc.

http://www.postgresql.org/docs/9.2/static/libpq-envars.html
Pode ser no bashrc.
export PGUSER=myFavouritePostgresUser
export PGDATABASE=db_nando

Agora já devemos estar podento digitar apenas "psql" pra logar sem
ter que especificar o password nem a database.

--------------------------- // ----------------------- // -----------------

Agora deve funcionar:
    pg_dumpall > postgressql_backup_completo_upgrade_para_9.2

    sudo rc.d stop postgresql (arch linux)

    cd /var/lib/postgres
    mv data bkp_data_9.1

    rc.d start postgresql
    rc.d stopt postgresql

    cp bkp_data_9.1/pg_hba.conf data/
    cp bkp_data_9.1/postgresql.conf data/


    vim data/pg_hba.conf

E seta
    host    all     all    127.0.0.1/32     md5
para
    host    all     all    127.0.0.1/32     trust

por que os passwords e usuários não vão funcionar mais.

    psql -U postgres


Criamos um usuário:

    CREATE ROLE admin WITH LOGIN PASSWORD 'admin' CREATEDB CREATEROLE; 
    ALTER USER admin VALID UNTIL 'infinity';

Colocamos uma senha para o superuser postgres:
    ALTER USER postgres WITH PASSWORD 'serect_passwd';

Recuperar os dados (deu alguns avisos aqui, mas funcionou tudo mesmo assim):

    psql -d postgres -f postgresql_backup_completo.sql

Coloca os 'trust' para 'md5' novamente no arquivo pg_hba.conf.

Reinicia o postgres e já deve estar tudo ok.


For further reading:

https://wiki.archlinux.org/index.php/PostgreSQL#Upgrading_PostgreSQL
http://www.postgresql.org/docs/current/static/upgrading.html



Anúncios

Idea – Java IDE + Vim

Posted in Dicas by Fernando Basso on 15 de setembro de 2012

Idea Java IDE e ideaVim

 

Recentemente iniciei meus estudos de Java, e realmente, por mais que eu prefira o Vim para tudo, é tortura querer programar Java nele, pois tem toda aquela história de packages, classes, access modifiers, imports, e tudo mais, e uma IDE especial para Java é muito mais prática do que o meu querido Vim.
Para mim, o problema com as IDEs é o editor, que são horríveis. Qualquer conhecedor de Vim (ou Emacs) sabe do que eu estou falando. As IDEs podem ter um milhão de qualidades, mas o editor não é uma delas, pelo menos não nas IDEs das quais eu já tive conhecimento até hoje.

Já tentei plugins para o Eclipse (eclim, vimplugin) e Netbeans (jVi). Ajudam bastante mas não consegui me adaptar a nenhum deles. Lendo na web acabei por encontrar alguém mencionando em um fórum dessa IDE chamada Idea, eu que havia um excelente plugin que oferece mode de edição igual ao Vim para ela. Resolvi testar.

http://www.jetbrains.com/idea/features/index.html

Idea – Instalação

No Arch Linux, basta instalar o pacote, pois está nos repositórios oficiais (pelo visto há uma versão paga também).


sudo pacman -S intellij-idea-community-edition

É lógico que você precisa ter o JDK e JRE instalado. Aparentemente, a equipe de desenvolvimento não suporta o OpenJDK oficialmente, mas dizem que funciona normalmente. Eu, particularmente, tenho os pacotes jre e jdk instalados do AUR (wiki, aur).

Apenas para constar, eu gerencio os pacotes provenientes do AUR usando o excelente aurget (todo em bash). Funciona perfeitamente bem para mim.

Depois de instalado, basta rodar, tanto pelo terminal, ou através de algum run-dialog (geralmente Alt+F2) e digitar


idea.sh

É um script que reside em /usr/bin/ e inicia a IDE para nós.
Na momento de criar o primeiro projeto, você será perguntando sobre o caminho do JDK no sistema. Basta executar o seguinte comando para descobrir:


echo $JAVA_HOME

No meu caso, no Arch Linux, bastou colocar /opt/java/ e pronto.

ideaVim

File –> Settings –> Plugins, clique em “Browser repositories” e pesquise por “ideaVim”. Clique com o botão direito em cima do nome do plugin  e escolha “Download and install”. Pode fechar as duas janelas clicando em OK e você verá a informação do download na parte inferior da janela principal da IDE. Apos instalado, basta reiniciar IDE e o plugin já deve vir habilitado por padrão. Em “Tools” você vai ver uma opção para habilitar e desabilitar o plugin.
Uma coisa que gostei bastante é que até Visual-Block Selection funciona, algo que senti falta em outros plugins para outras IDEs. Uso isso muito para comentar pedaços inteiros de código quando necessário. Para quem não sabe, imagine que você quer comentar as primeiras 5 linhas de código, basta se posicionar na primeira coluna (caractere) da primeira linha (no modo normal), pressionar Ctrl-V, 5jI// e então pressionar <Esc>. Para remover faz-se a mesma seleção e digita-se algum comando de deleção, como o “x”, por exemplo.
Outra coisa que gostei é a maneira como a IDE usa uma leve linha pontilhada mostrando o abrir e fechar de blocos, embora ele mostre o qual { é o par que casa com um } e vice-versa destacando-os com uma cor diferente, assim como o Vim já faz por padrão.

Dicas

Ctrl+Shift+a permite que você pesquise por uma opção ou configuração. Tente pesquisar por plugins, por exemplo. Ctrl+Shift+n permite pesquisar e abrir arquivos.

Outra muito legal, é quando, digamos que você está no main() usando um método chamado listFuncionarios(). Com o cursor em cima do nome do método, digitar Ctrl+Alt+b leva você para a classe e local de definição do método. Isso muito útil já que muitas vezes, somente ao utilizarmos um método percebemos falhas e então temos que voltar nele e melhorar o código.

De vez em quando, acesse Help –> Productivity Guide, clique em “Used” de forma a deixar a setinha apontando para baixo, e dê uma olhada nas coisas para ver o que você usa mais, e o que você poderia estar usando mas não está.

Shortcuts são sempre bem vindos:

http://www.jetbrains.com/resharper/webhelp/Reference__Keyboard_Shortcuts.html

http://stackoverflow.com/questions/294167/what-are-the-most-useful-intellij-idea-keyboard-shortcuts
Se alguém quiser dar sugestões e dicas, pode mandar nos comentários (os créditos serão reconhecidos). Quem tiver algum post sobre issa excelente IDE, por favor não deixe de compartilhar também.

Tagged with: , , ,

Indetação no Vim – Tabs e Espaços

Posted in Dicas, Linux, Vim by Fernando Basso on 11 de janeiro de 2012
======================================
= Indentação no Vim - Tabs e Espaços =
======================================

= Introdução =
--------------

Há duas maneiras de indentar um código fonte:
  1. com tabs reais, também chamado de hard tabs.
  2. com espaços no lugar de tabs (sim, o vim pode ser configurado para
     substituir uma tabulação por um certo número de espaços).

Há vantagens e desvantagens em cada um dos métodos. Há alguns artigos que
discutem o assunto na web, embora parece que mais pessoas preferem Espaços
no lugar de Hard Tabs, mas isso é pura questão de gosto, e cada caso é um
caso.

Basicamente temos as opções:
 1.     'tabstop' - altera a largura da tabulação (Tabs reais).
 2.   'expandtab' - causa espaços serem usados/inseridos no lugar de
                    caracteres Tab.
 2. 'softtabstop' - configura detalhadamente a quantidade de espaço a serem
                    inseridos quando a tecla Tab é pressionada.
 3.  'shiftwidth' - afeta o uso de ">>", "<<", modo normal, "Ctrl-t" e
                    "Ctrl-d" no Modo Insert, além de ter influência em como
                    indetação automática funciona.

Para iniciar , execute isso no vim:
    :set list 
    :set listchars=tab:T_ 

A partir de agora, toda vez que o vim "enxergar" um Tab real, ele vai
mostrar algo como "T_____" no lugar do tab, para que o Tab fique 
visualmente percebível.

Pra desabilitar basta fazer:
    :set nolist 


= Indentação com Hard Tabs Apenas =
-----------------------------------

Por padrão, o vim vem configurado com:
  tabstop = 8 
  softtabstop = 0 
  shiftwidth = 8 
  noexpandtab 

Independente da sua configuração, digite esta linha para testar
(simplesmente coloca os valores default):
    :set tabstop=8 softtabstop=0 shiftwidth=8 noexpandtab 
 
O que acontece então?
 1. Com essa configuração, pressionar a tecla Tab no modo insert insere um
    caractere Tab real, com largura de 8 colunas. 
 2. Nesse caso, o  deleta o caractere Tab (deleta 8 colunas), o
    que visualmente parece que vários espaços foram deletados ao mesmo tempo.
 3. No modo Normal, usar >> e <> e <> e <> e << insere ou deleta *4* espaços. O mesmo
    occorre ao se pressionar Ctrl-t e Ctrl-d no modo Insert.

= Espaços = Caso 4 =
--------------------

Mas (note o NOexpandtab): 
    :set tabstop=8 softtabstop=4 shiftwidth=4 noexpandtab 

Agora, 'noexpandtab' não está habilitado, e portanto, pressionar 
insere um Tab real (e não espaços no lugar do Tab). Se pressionar Tab, e
'tab=8', um Tab terá largura de 8 colunas.

Como você sabe, ">>", "<>" duas vezes.
Você vai notar que ele se transforma em um Tab real. Isso porque "tabstop=8"
e "shiftwidth=4", etão, 4 + 4 = 8. Se "tabstop=12", por exemplo, então
pressionar ">>" 3 vezes se gera uma Tab real, porque 4 + 4 + 4 = 12.  

Isso tudo acontece porque 'softtabstop' tem precedência sobre 'tabstop'.
Então, quando pressionamos, por exemplo, "Ctrl-t" uma vez, ele insere 4
espaços, mas quando pressionamos "Ctrl-t" uma segunda vez, ele diz "Hmm,
isso está igual a "largura" do 'tabstop', e então os 8 espaços são
deletados e um Tab real é inserido. Quando usamos , "Ctrl-d" ou
"<<", o processo inverso ocorre.


= Misturando - Caso 5 =
-----------------------

Vamos deixar 'tabstop' igual 4, com 'expandtab' desabilitado:
    :set tabstop=4 softtabstop=4 shiftwidth=4 noexpandtab 

 1. Agora, como 'tabstop' está igual 'shiftwidth' e 'expandtab', quando
    , ">>" ou "Ctrl-t" for pressionado, uma Tab real será inserida
    pois o Vim notou que as configurações estão iguais. Quando as
    configurações estão iguais.

NOTE que tabs reais e espaços antigos no arquivo continuam sendo o que eram.
O que pode mudar é o tamanho das Tabs reais, mas não o fato de serem Tabs
reais ou não. O que já era Tab real continua sendo Tab real, e o que era
(grupos) de espaços continuam sendo (grupos) de espaços (grupos de espaços
que por venturam tenham sido inseridos em lugar de Tabs reais).

= Possíveis Escolhas =
======================

= Hard Tabs (Tabs Reais) =
--------------------------
Quem prefere trabalhar com Tabs reais, uma boa escolha é deixar 'tabstop'
igual 'shiftwidth', pois eles trabalharão de maneira consistente e
homogênea. Espaços não serão usados.

= Espaços em vez de Tabs Reais =
--------------------------------
Deixar 'softtabstop' igual 'shiftwidth' assegura que ">>", "<<",
"Ctrl-t" e "Ctrl-d" adicionem e removam Tabs (não reais, pois agora é
substituída por espaços) com o mesmo comportamento de se adicionar e deletar
tabs pressionando a tecla  e . Ou seja, todos eles vão
adicionar ou remover o mesmo número de espaços - vão funcionar de forma
homogênea. Pode-se também, nesse caso (e alguns acham aconselhável), deixar
'tabstop' com o mesmo valor de 'shiftwidth' e 'softtabstop'.

-------------------------------------------------------------------------------

= Notas Finais =
---------------------

Saiba que o Vim permite configurar tudo isso de acordo com o 'filetype'. Por
exemplo, é possível configurar que arquivos "html" utilizem 2 espaços no
lugar do Tab, um arquivo em "C" utilize 4 espaços no lugar de um Tab, e
ainda, quando um arquivo "bash" for editado, um Tab real de 6 colunas seja
usado. Ou seja, quando o arquivo é aberto, o vim usa as configurações
predefinidas automaticamente.

Alguns exemplos.

Vamos criar os diretórios necessários:
    mkdir --parents ~/.vim/after/ftplugin/ 

Para HTML:
Criar o um arquivo chamado "html.vim" dentro do último diretório criado:
    vim ~/.vim/after/ftplugin/html.vim 

E coloque o seguinte conteúdo dentro do arquivo:
    set softtabstop=2 expandtab shiftwidth=2 


Para CSS:
Criar o arquivo css.vim, no mesmo diretório que do exemplo anterior:
    vim ~/.vim/after/ftplugin/css.vim 

E cole o seguinte conteúdo:
    set softtabstop=4 expandtab shiftwidth=4 


Para "bash", com Hard Tabs:
    vim ~/.vim/after/ftplugin/bash.vim 
E cole:
    set tabstop=6 softtabstop=6 shiftwidth=6 noexpandtab 


= Dica final =
--------------

Se você optar por usar Espaços no lugar de tabs, há uma maneira de inserir
Tabs reais sem ter que mudar temporariamente a configuração. Isto é
conseguido inserindo-se caracteres não imprimíveis literalmente. 

No vim, isso é muito fácil. Basta pressionar "Ctrl-v" no modo Inserte, e
então pressionar a tecla Tab em seguida. Passo-a-passo:

            vim --> abre o vim no terminal (poderia ser o gvim).
              i --> entra no modo insert na posição onde está o cursor.
         Ctrl-v --> pressionar a combinação "ctrl-v". Vai aparecer um
                    caractere parecido com um "^". Neste momento, o Vim está
                    esperando você digitar o caractere que termina a
                    sequência, no nosso exemplo, um .
           --> pressione Tab.
  "hello world" --> escreva "hello world" por que esse é um encantamento que
                    garante que você aprenda o conteúdo. Sempre foi assim em
                    todas as linguagens, e essa é a razão. São palavras
                    mágicas.

Como mesmo exemplo você poderia inserir um caractere  ou 
literalmente no texto.

Aqui está o arquivo que fiz no Vim, mas convertido para html. Tive que renomear para .pdf para fazer o upload. Depois de baixar, troque a extensão para .html novamente e abra no seu navegador favorito. Está bem colorido, facilitando a leitura.
Indentando_Código_Fonte_no_VIM

Referências:
------------
    
  No Vim:
    :help 'softtabstop'
    :help 'tabstop'
    :help 'shiftwidth'
    :help 'expandtab'

    http://vimcasts.org/

    http://vim.wikia.com/wiki/Indenting_source_code




Bash – comandos, argumentos e a importância das apas

Posted in 5584, Linux by Fernando Basso on 4 de janeiro de 2012

Intro

Interactive mode: modo de operação onde um prompt de comando espera que você digite um comando por vez.

Script: um arquivo que contém uma sequência de comandos para serem executados um após o outro.

Ao iniciar o Bash, bash –posix ou set -o posix se o Bash já está em execução coloca o Bash em modo POSIX.

No Arch Linux (e quase todas as outras distribuições), /bin/sh é um symlink para /bin/bash. Se o Bash é invocado com o nome “sh”, ele tenta imitar o comportamento de versões históricas do sh o melhor possível, enquanto conformando com o padrão POSIX. Neste modo, o Bash lê os arquivos de inicialização e então entra em modo de compatibilidade com o padrão POSIX.

/etc/profile é lido por todos todo Bourne-compatible shell no login. Ele configura o ambiente e carrega configurações específicas a certas applicações (/etc/profile.d/*.sh).

.profile é lido pelo Bash quando um shell com login interativo é iniciado.

.bashrc é lido pelo Bash quando um interativo non-login shell é iniciado, por exemplo, quando alguém abre um console virtual (x terminal) a partir de um Window Manager ou Desktop Environmen (Openbox, LXDE, Gnome, KDE, etc.). Este arquivo é útil para configurar o ambiente de shell específico do usuário.

Leia mais: https://wiki.archlinux.org/index.php/Bash

Comandos e Argumentos

 O Bash lê linhas do terminal (usuário digitando comandos) ou de arquivos. Cada linha é uma comando – uma tarefa para ser executada.

 IMPRTANTE: O Bash divide cada linha em palavras. Palavras são separadas por espaços.

 A primeira palavra em uma linha/comando é o nome do comando. Todas as outras (palavras) são os argumentos que são passados para o comando especificado.

 echo This is a test echo → é o nome do comando;

this → é um argumento.

is → outro argumento.

a → mais outro argumento.

test → ainda mais um argumento – e o último, no exemplo.

 MAS:

echo"This is a test"

echo → é o nome do comando.

“This is a test” → é um único argumento.

 As aspas não são parte do argumento. O Bash as remove antes de lidar com o argumento.

 CUIDADO: Digamos que temos dois arquivos em um diretório. Os arquivos são:

“The secret voice in your head.ogg”

“secret”

 “secret” contém um segredo muito importante que pode salvar o mundo.

E agora você faz:

 rm The secret voice in your head.ogg

 O Bash vai pensar que você passou seis argumentos, e um deles é “secret” – seu venerado arquivo. Você recebeu erros porque o comando rm não conseguiu remover/encontrar os arquivos “The”, “voice”, “in”, “your”, e “head.ogg” (já que eles não são arquivos por si próprios), exceto “secret”, é que sim um arquivo. É por isso quo Bash reclamou dos outros mas não reclamou de “secret”. Agora o pior: o arquivo chamado “secret” já era. Para sempre se foi (não tem lixeira na linha de comando), e a música (que é o que queríamos deletar) ainda está lá. A maneira correta é usar apas:

 rm “The secret voice in you head.ogg”

Assim, você está agrupando todas as palavras em um único argumento. Descanse em paz. O “segredo” está seguro agora.

 Veja este próximo caso.

 [ é um comando, similar ao comando test. Se testarmos alguma coisa assim:

 [-f file.txt]

 …está errado. -f não deve estar “colado” ao [. Devemos separá-los. [ é o nome do comando, portanto uma palavra. -f é a segunda palavra (um argumento), file é a terceira palavra (outro artumento) e o ] é o ultimo argumento – que é mandatório toda vez que usamos [. Esta é a maneira correta (note os espaços):

 [ -f file.txt ]

 A propósito, uma maneira mais aconselhável ainda é colocar o nome do arquivo entre aspas (você já viu o que pode acontecer se um nome de arquivo contém espaços, e não o protejemos com aspas).

 [ -f “my file” ]

É boa prática sempre usar apas.

 Uma dica rápida: use o perl-rename para mudar todos os espaços nos nomes dos arquivos por underscores:

 perl-rename ‘s/ /_/’ ./*.txt

 …para arquivos .txt (mude a extensão para outros tipos de arquivos), ou

 perl-rename ‘s/ /_/’ ./*

 …para todos os arquivos do diretório.

 NOTA: No Arch Linux, no nome é perl-rename. prename em outras distros – não confunda com rename, que é um comando bem simplificado e não faz o que o exemplo mostra. (Se não me engano já vi uma distro em que rename era na verdade o um symlink para o perl-rename).

Este conteúdo é basicamente um tradução livre do (excelente) site:

http://mywiki.wooledge.org/BashGuide

Este conteúdo não é, de forma alguma, mérito meu, mas sim dos proprietários do site acima mencionado.

Simular margem no vim para ler o :help

Posted in Bash, Dicas, Linux, Vim by Fernando Basso on 1 de janeiro de 2012

Simular margem no vim para ler o :help

Uma coisa que me incomoda quando estou lendo o :help no vim é que o texto fica “grudado” na borda esquerda da janela do vim (ou gvim). Então, o que costumo fazer é habilitar os números de linha com :set number. para ter algo no lado esquerdo da janela funcionando como uma espécie de margem.

Tem dois detalhes que me incomodam. Um é que não adiante colocar set number no vimrc porque help é um filetype no vim, então, as configurações do filetype help (que usa set nonumber) sobrescreve o set number do vimrc. Outra coisa é que ter números de linhas para ler o help pode não agradar muito ou fazer muito sentido. Fortunadamente, há uma maneira de simular uma margem, sem que fique aparecendo os números.

Entendendo o processo

Quando usamos a opção set number, o vim usa um espaço ao lado esquerdo da janela para mostrar esses números, e também nos fornece os grupos de cor chamados LineNr que é justamente para definir a cor que aparece naquela parte onde os números são mostrados, tanto o background como o foreground.

Pois bem, se configurarmos LineNr para ter a mesma cor de background que do resto do vim não veremos diferença de cor entre o fundo do texto normal e a cor da região usada para mostrar o números das linhas. Ainda mais, se configurarmos a cor que LineNr usa para mostrar os números propriamente ditos para a mesma cor do background, não vamos ser capazes de ler/ver número algum, pois a cor do texto será exatamente igual a cor de fundo. Os números ainda estão lá, mas não dá pra notar.

O que vamos fazer então é criar (se já não existir) o diretório ~/.vim/after/ftplugin. O comando abaixo se encarrega disso, e se os diretórios já existem, ele simplesmente não faz nada:

mkdir --parents ~/.vim/after/ftplugin

Precisamos criar também, (se já não existir) o arquivo help.vim dentro de ~/.vim/after/ftplugin/:

vim ~/.vim/after/ftplugin/help.vim

Agora, vamos descobrir quais as cores que o nosso colorscheme está usando para o background. Os grupos de cores para isso são ctermbg (background no terminal) e guibg (background no gvim). Para descobrir as cores configuradas para os grupos mencionados, execute os seguinte comando:

:highlight Normal

Isso vai mostrar as cores configuradas para ctermfg, ctermbg, guifg, entre outras coisas.

Para ter certeza da cor que o gvim usa como background (há fatores que podem fazer com que o vim no terminal use cor x, e o gvim use cor y para determinado grupo) é mais seguiro abrir o gvim e rodar o mesmo comando para ver o que ele mostra sobre si próprio para guifg e guibg.

NOTE que o comando é digitado no modo de comando do vim. Entramos no modo de comando quando, estando no modo normal pressionamos : (chegamos no modo normal pressionando <Esc> ou CTRL-[).

Finalmente, no ~/.vim/after/ftplugin/help.vim colocamos o configuramos os backgrounds e foregournds para o vim e gvim com os valores das cores conforme foram mostrados com o comando anterior.

set number
highlight LineNr ctermfg=235 ctermbg=235 guifg=#dfd6c1 guibg=#242424

Veja, a cor do ctermfg, ctermbg, guifg e guibg são iguais (fg = FackGround, bg = BackGround). E lembre-se que essa cor é igual a cor do background da janela normal do vim. Isso cria a impressão que há uma margem.

De agora em diante, toda vez que você abrir um :help no vim, terma uma “margem” no lado esquerdo da janela. Pra mim pelo menos, parece tornar a leitura mais confortável.

Colocando em uma função (opcional)

Podemos também deixar a configuração padrão do vim ficar como é quando abrimos um :help, e colocar o código que criamos em uma função, e criar uma outra função que desabilita a margem.

A função que habilita:

function! CriaMargem()
 set number
 highlight LineNr ctermfg=235 ctermbg=235 guifg=gray16 guibg=gray16
endfunction

Para criar a função que desabilita a margem, vamos descobrir a as cores que são definidas para LineNr por padrão. Certifique-se de que não tenha chamado a função acima e não tenha aberto um :help usando o nosso truque, senão o comando abaixo não vai mostrar as cores originais. Em todo caso, rode o comando (novamente, no modo de comando):

:hightlight Normal

E coloque as cores que aparecerem aí na função que desabilita a margem (volta as cores padrão para que possamos ver os números):

function! MargemOff()
 highlight LineNr ctermfg=180 ctermbg=242 guifg=#cdaa7d guibg=bg
endfunction

Essas funções também vão dentro do help.vim que criamos. Chame as funções assim no vim:

:call CriaMargem()

e

:call MargemOff()

Pode usar <Tab> para autocompletar.

Note que colocando essas funções no ~/.vim/after/ftplugin/help.vim, elas só estarão disponíveis quando você estiver lendo um :help no vim. Portanto, não adianta esta editando um html, C, ou perl e querer chamar essas funções. Se quiser que elas fiquem disponíveis para outros filetypes, coloque-as no ~/.vimrc.

Supondo que deixamos elas no help.vim, vamos deixar CriaMargem() habilitada por padrão. Para tal, basta chamar a função de dentro do próprio help.vim. Aqui vai o exemplo completo:

" Habilita a simulação de margem.
function! CriaMargem()
 set number
 highlight LineNr ctermfg=235 ctermbg=235 guifg=gray16 guibg=gray16
endfunction
" Mostra set mumber normalmente.
function! MargemOff()
 highlight LineNr ctermfg=180 ctermbg=242 guifg=#cdaa7d guibg=bg
endfunction

” Vamos deixar a função habilitada por padrão.

autocmd BufEnter * call CriaMargem()

Com certeza deve ter como colocar tudo em uma única função, tornando o código mais profissional, mas no momento em que escrevo, é o que deu pra fazer sem perder muito tempo.

Tagged with: , , , ,

Expressões regulares no Vim – Update 1

Posted in Vim by Fernando Basso on 31 de dezembro de 2011

Expressões Regulares no Vim

Boa parte do que está aqui é uma adapatação do :help usr_27.txt (arquivo de ajuda integrada do Vim).

Básico

Início e fim de linha

 :help 03.9 (Simple search patterns)

Use as opções :set incsearch e :set hlsearch para praticar. Para “resetar as cores”, :nohlsearch. Crie um arquivo com pedaços de texto que torne possível praticar as dicas aqui apresentadas.

O caractere ^ faz correspondência ao início da linha. O caractere $ corresponde ao fim da linha.

Econtra “teste” somente se estiver no final da linha:

 /teste$

Encontra teste somente se estiver no início da linha;

 /^teste

Encontra “teste” somente se ele for a única coisa da linha. Não pode haver espaços nem antes e nem depois de “teste”:

 /^teste$

Qualquer caractere uma vez

O . (ponto) corresponde a qualquer caractere – uma vez.

Corresponde a “abc”, “azc”, “aYz”, “a b”, “a-b”, etc:

 /a.b

Escapar caracteres especiais

Se queremos encontrar literalmente um ponto, devemos escapar o ponto, pois no vim ele é um caractere especial.

Se fizer somente

 /.

vai corresponder a todos os caracteres, até mesmo espaços em branco. Para encontrar somente o ponto literalmente:

    /\.

Escapando o . ele se torna um reles mortal e perde todos os seus superpoderes de caractere especial.

RegExp nível intermediário

:help usr_27.txt

Ignorando maiúsculas e minúsculas

Por padrão, o vim é sensível à caixa da letra. Portanto, “else”, “ELSE”, Else” são palavras diferentes. Para que o vim ignore a caixa da letra (case):

 :set ignorecase

Agora, tanto faz procurar por “else”, “ELSE”, ou “Else”, pois o vim vai tentar encontrar a palavra não importa quais letras nes estejam maiúsculas ou minúsculas.

Para voltar a se importar com o case da letra:

 :set noignorecase

Há também a opção smartcase, que é “ignorecase” por padrão, mas se você realizar a procura com pelo menos uma letra maiúscula o vim detecta e passa a ser sensível ao case automaticamente.

 :set ignorecase smartcase

Para fazer procura sensível à caixa em uma pesquisa apenas, usamos \C (maiúsculo):

 /\Cteste
 /\CTeste

O primeiro só combina com “teste”, todas minúsculas. O segundo só combina com “Teste” com o primeiro “T” maiúsculo.

Para tornar a pesquisa insensível ao case use \c (minúsculo):

 /\cteste

Encontra “teste”, “TESTE”, “teSTE”, etc.

A vantagem de usar \c e \C é que eles ficam no histórico junto com o ‘pattern’ da pesquisa.

NOTA: O uso de \ depende da opção magic. :help ‘magic’.

Offsets de linhas

Quando fazemos uma busca, o cursor para na linha da busca. Se queremos parar duas linhas após o elemento procurado:

 /teste/2

Offset de caracteres

Parar o cursor no último caractere do elemento procurado (e = end):

 /teste/e 

Coloca o cursor 3 caracteres após o último caractere do elemento procurado:

    /teste/e+3

Coloca o cursor no penúltimo caractere do elemento procurado:

 /teste/e-1

Coloca o cursor na segunda no terceiro caractere do elemento buscado (b = beggin):

 /teste/b+2

É b+2 por que b já é o primeiro caractere, então + 2 dá 3.

Estes offsets serão mais úteis quando estudarmos o conteúdo do :help pattern.txt.

Expressões Regulares no BASH – Parte 2

Posted in Bash by Fernando Basso on 25 de dezembro de 2011

BASH – Expressões Regulares – Parte 2

Sunday, 10:47 – December 25 – 2011

  1. Extrair Nome do Script ou o Path para o Script
  2. Verificando por Sub-Strings
  3. Substituições Básicas
  4. Remover do início da string
  5. Remover do fim da string

Dando continuação aos exemplos do primeiro tutorial sobre expressões no
bash, vamos a mais alguns exemplos diversos, que basicamente usam o que já
aprendemos anteriormente.

Extrair Nome do Script ou o Path para o Script

Sabemos que no linux os caminhos de diretórios são compostos pelos nomes
dos diretórios separados pela barra (/). Em muitos dos nossos próximos
exemplos, a barra não será usada como delimitador, mas como o próprio
elemento que queremos encontrar. Tenha isso em mente enquanto estuda os
próximos exemplos.

A variável “$0” é interna do bash, e ela mostra o nome do script.
Se executamos o script do diretório onde ele está, tudo bem, o output
mostrará o nome do script normalmente.

echo "$0"

É lógico que a variável $0 só fará sentido se utilizada
dentro de um script. Para testar pela linha de comando podemos simular
criando uma variável que contém um path (caminho) qualquer e usar a essa
variável em vez de $0:

var="/usr/local/bin/my_script"

Continuando o assunto, se o script está em /usr/local/bin/
por exemplo, então $0 vai mostrar o caminho completo do arquivo, e não
apenas o nome dele. A solução é deletar a parte que não queremos.

echo "${0##*/}"

NOTE que agora o / não é mais o delimitador. Ele é o próprio
caractere que queremos encontrar. Suponha que o script se chama
my_script, então o caminho completo será
/usr/local/bin/my_script. Em português ficaria “mostre o
conteúdo da variável $0, e delete tudo (*) até a ultima barra possível (/).
Restará só o nome final: my_script

.

Por outro lado, se queremos mostrar somente o caminho, sem o nome do
arquivo propriamente dito, temos que deletar de trás pra frente, usando o
'%' ou o '%%'.

echo "${0%%/*}"

Em português, “do final da string (%%), delete tudo (*) até encontrar a
barra (/). Sei que é estranho, por que mesmo sendo de trás pra frente, o
‘%%’ continua logo após a variável, como é o caso do ‘#’ ou ‘##’. O jeito é
acostumar, pois é assim mesmo.

Os créditos do próximo exemplo vão para mywiki.woolege.org. A
única coisa que fiz foi tentar explicar de uma maneira um pouco
diferente.

Digamos que não queremos apenas o nome final, mas as duas ultimas partes.
Bom, vamos pensar um pouco por vez. Primeiro, pegamos as partes que não
queremos, e salvamos em uma variável. Antes vamos testar. Vamos ver se a
expressão está realmente mostrando somente a parte que não queremos:

echo "${var%/*/*}"

Deleta do final até a primeira barra (/*) e deleta mais uma vez até a
próxima barra (/*). Por isso usamos /*/*. Agora sim, assine
essa regexp na variável tmp. Veja que executando o
echo, acima na verdade a espressão está deletando as duas ultimas
partes. Não tem problema, desde que salvemos essa expressão na variável.

tmp="${var%/*/*}"

Para se certificar de que a expressão está correta, vamos ver o que foi
salvo na var tmp:

echo "$tmp"

tmp agora possui '/usr/local'. Vamos então
deletar do início da string, todo o conteúdo que está em
tmp:

echo "${var#$tmp}"

É o mesmo que:

echo "${var#/usr/local/}"

Ou seja, deleta '/usr/local' deixando somente o final que
queriamos '/bin/my_script'. Faça você mesmo várias vezes e
invente exemplos próprios parecidos com esse até acostumar.

Mais um exemplo:

var="nada importante <jackpot> ... não interessa"

Agora, por algum motivo, queremos ficar somente com jackpot:

tmp="${var##*<}" # Remove do início até o <.
echo "${tmp%>*}" # Remove do > até o fim da string.

Pronto, só nos restou o que estava entre < e >.

Mais um exemplo:

      var="Isto é 'melhor' que aquilo."
      tmp="${var#*\'}" # Temos que escapar a aspa simples (\').
      echo "${tmp%\'*}" # Sobra apenas "melhor" (sem as apas).
    

Voltar


Trabalhando Com Posições Fixas – Ranges

Se sabemos quantos caracteres à direita ou a esquerda queremos, fica muito fácil:

var="ABCDEFGHIJ"

Mostramos somente os dois primeiros caracteres, ou seja, do zero ao dois:

echo "${var:0:2}"

Mostrar as últimas três posições, ou seja, da posição 7 a posição 10:

echo "${var:7:10}"

O mesmo pode ser conseguido com:

echo "${var:(-3)}"

Tenha cuidado com a sintaxe.

Em construção…

Expressões Regulares no BASH – Parte 1

Posted in Bash by Fernando Basso on 24 de dezembro de 2011

BASH – Expressões Regulares

Saturday, 10:33 – December 24 – 2011

  1. Introdução
  2. Verificando por Sub-Strings
  3. Substituições Básicas
  4. Remover do início da string
  5. Remover do fim da string

Introdução

Estes exemplos podem ser digitados diretamente na linha de comando, ou
então colocados em em arquivo. Não vou explicar isso detalhadamente agora, mas
um escript bash pode ser algo como esse exemplo:

  #!/usr/bin/env bash

  # Descomente a próxima linha para um output mais verbose.
  #set -xv

  var="May the force be with you. Always! - Master Yoda."
  echo "$var"

  if [[ -z "$var" ]]; then
      echo "A string é vazia."
  else
      echo "A string não é vazia."
  fi # Fim do 'if'.

  # Script termina aqui.

Com o terminal na pasta onde está o script, execute este comando para
rodar o script:

bash nome_do_script

Vamos criar uma variável contendo uma string. Essa variável/string
será usada nos exemplos.

var="May the force be with you. Always! - Master Yoda."

Mostrar quantos caracteres uma string possui.

echo "${#var}"

Voltar


Verificando por Sub-Strings

Colocamos a sub-string desejada entre ‘*’ (o chamado glob). Vamos
verificar se a string contém a sub-string ama:

#!/usr/bin/env bash
var="programador"
if [[ "$var" = *"ama"* ]]; then
    echo "<$var> contém a substring <ama>."
else
    echo "<$var> não contém a substring <ama>."
fi

Colocando a sub-string e uma variável, o código ficaria assim:

#!/usr/bin/env bash
var="programador"
substr="ama"
if [[ "$var" = *"$substr"* ]]; then
    echo "<$var> contém a substring <$substr>."
else
    echo "<$var> não contém a substring <$substr>."
fi

Voltar


Substuições Básicas

Usamos a barra (/) como delimitador.

Substituir ‘e’ por ‘E’. Somente a primeira ocorrência:

echo "${var/e/E}"

Para mudar todas as ocorrências de ‘e’ para ‘E’, usamos a barra duas vezes.
Dizemos que substitui globalmente.

echo "${var//e/E}"

Para efeito de ilustração, suponhamos que queremos substituir o ‘e’
mais os próximos dois caracteres, não importa quais sejam, por 1, 2 e 3
respectivamente:

echo "${var//e??/123}"

Substitui o ‘!’ por um ponto final ‘.’. Precisamos escapar o
ponto de exclamação pois ele é um caractere especial no bash.

echo "${var/\!/.}" # O . não é um metacaractere no bash. 

Subsituir spaços em branco por underscores – globalmente.

echo "${var// /_}"

Substituir . por …:

echo "${var//./...}"

Voltar


Remover do Início da String

Para remover parte do início de uma string, não usamos mais o delimitador (/).
Usamos apenas o ‘#’ ou ‘##’. Vamos aos exemplos.

Remover do início até o primeiro espaço. Um único # é non-greedy (não
ganancioso/guloso).

echo "${var#* }"

Explicando: o # busca pelo início, o * é tudo, e o espaço em branco é o
que queremos encontrar. Então, em português ficaria algo como “do início da string (#),
tudo o que for possível (*), até o primeiro espaço em branco que encontrar ( )”.

Remove do início até o último espaço em branco possível. ## é
greedy.

echo "${var##* }"

NOTE que o glob vai ANTES do item que queremos encontrar. No
exemplo, o * vem antes do espaço em branco.

Parar antes do ponto, ou seja, não incluir o ponto.

echo "${var##*([!.])}"

# ! é o operador de negação ou “NOT”.

Remove tudo, do início até o hífen (-).

echo "${var#*-}"

Remove do início até o espaço que vem após o hífen.

echo "${var#*- }"

Colocando em português, “do início (#), tudo (*),continua até o hífen (-), e inclui o espaço em branco ( )”.

Voltar


Remover do Final da String

var="May the force be with you. Always! - Master Yoda."

Agora procuramos para trás. Por isso, o * vai do lado oposto do que
vinhamos usando até agora e o operador ‘#’ muda para ‘%’.
Pra frente: “${var#*-}”
Pra trás: “${var%-*}”
– é o que queremos encontrar. É importante observar que agora a expressão
começa e ser procurada do fim do string e vai “caminhando” até o início

Remove do fim até o primeiro espaço – contando de trás pra frente. Ou
seja, o último contando do início.

echo "${var% *}"

Remove do final até o último espaço – contanto de trás pra frente. Ou
seja, o primeiro contando normalmente.

echo "${var%% *}"

Remove do fim até o hífen

echo "${var%-*}"

Remove do fim até o primeiro ‘ç’ que encontrar:

echo "${var%ç*}"

Se o caractere que queremos encontrar ocorre mais de uma vez na string,
e queremos encontrar justamente a ocorrência dele que está o mais distante
possível do final da string, usamos ‘%%’ em vez de ‘%’. O ‘e’ mais distante
do final da string nesse caso está na palavra ‘Que’ bem no início. Veja
como ficaria o código:

echo "${var%%e*}"

Voltar


A maior parte do que postei aqui eu aprendi no site
wooledge.org – um excelente site
sobre shell scripting com o bash. O que não aprendi lá aprendi lendo na web, conversando em IRCs, forums, e nos –help e man (que confesso serem
difíceis de entender as vezes).

Por enquanto é isso. Teremos mais exemplos em futuros posts.

Tagged with: , , ,