Jedi Tux

acidentes comando rm – trash-cli

Posted in Bash, Dicas by Fernando Basso on 7 de janeiro de 2012

Fiz esse arquivo no vim. Quem quiser pode baixar a versão que converti com o :TOhtml.
rm_accidents.smr
NOTA: O wordpress não me permitiu fazer upload do arquivo html, nem zip, então eu renomeei ele para .pdf para poder fazer o upload. Baixe o arquivo e renomeie a extensão para .html novamente antes de tentar abrir o arquivo.

=============================
= Rm - Previnindo Acidentes =
=============================


= Tópicos =
-----------
  - Comando rm não tem trash
  - Solução nº 1 - interactive mode
  - Solução nº 2 - um alias para o interactive mode
  - Solução nº 3 - trash-cli - lixeira na linha de comando

== Comando rm não tem trash ==
------------------------------

Cuidado!!! No terminal, na linha de comando, quando se digita
    rm segredo_mundial.txt
o segredo_mundial.txt já era. Não tem mais o que fazer.

===============================================================================

== Solução nº 1 - interactive mode ==
-------------------------------------

Sempre use a opção "-i", ou "--interactive" com o comando "rm" e torne isso
um hábito. Essa opção se prontifica a nos perguntar se realmente desejamos
deletar o arquivo.
    rm -i segredo_mundial.txt
    rm --interactive segredo_mundial.txt

CUIDADO com a flag "-f" ou "--force". Com ela, as opções "-" ou
"--interactive" se tornam inúteis, ou seja, eles são completamente
igonorados. 

Há um truque que pode ser aplicado. Digamos que temos um diretório
contendo arquivos muito importantes. Podemos criar um arquivo chamado "-i"
dentro desse diretório. Como o arquivo contém "-" no nome, não podemos
simplesmente fazer "touch -i", pois o comando "touch" vai pensar que estamos
passando a opção "-i" como argumento, e o comando "touch" nem tem uma opção
chamada "-i". As duas possíveis maneiras de criar o tal arquivo estão
exemplificadas abaixo:
    touch -- -i
ou
    touch ./-i


A partir de agora, se você fizer
    rm -Rf *
o shell vai expandir o "-i" na linha de comando, de tal forma que seu
comando na verdade se transforma em
    rm -Rf -i

Note que isso só funciona se você usar o "glob" (*). Se tentar deletar um
arquivo por vez, o arquivo "-i" não vai te ajudar. Vamos aprender outro
truque quando falarmos do programa "trash-cli".

Se quiser remover o arquivo "-i", não basta fazer rm -i porque o rm tem de
fato a opção "-i". Então "rm -i" é o comando "rm", seguido da opção "-i",
mas ainda falta dizer ao "rm" qual arquivo ou arquivos deletar, por que ele
não sabe que "-i" é um arquivo e não uma opção. Usamos uma técnica similar a
que usamos para criar o arquivo. As duas soluções possíveis são:
    rm -- -i
ou
    rm ./-i


===============================================================================
== Solução nº 2 - um alias para o interactive mode {{{
------------------------------------------------------

A solução número dois consiste em colocar o que apprendemos acima em um
"alias" (um "apelido", em Inglês). Vamos criar um alias que faz com que o
comando "rm" sempre seja executado com "rm --interactive".
    alias rm='rm --interactive'

Digite o comando acima em um terminal e tente remover um arquivo (não teste
com nada que seja importante). Para testar, rode apenas "rm arquivo.txt" e
você vai notar que ele pergunta se temos mesmo certeza de que queremos
deletar o arquivo em questão.

Se você gostou da ideia coloque o comando que cria o alias no ~/.bashrc.
Para que o alias entre em vigor, feche e abra o terminal novamente ou rode
o comando:
    source ~/.bashrc

A partir de agora, toda vez que você digitar "rm", o bash interpreta o alias
e na verdade vai executar "rm --interactive". 

===============================================================================
== Solução nº 3 - trash-cli - lixeira na linha de comando ==
------------------------------------------------------------

Instale o programa "trash-cli". Enquanto escrevo este documento, "trash-cli"
está disponível pelo AUR para o Arch Linux, mas pesquisas pela web fazem
acreditar de que já está nos repositórios oficiais de muitas distribuições.

O programa "trash-cli" vem com três comandos principais:
    1. trash-empty - esvazia a lixeira;
    2. trash-list - lista os arquivos da lixeira;
    3. trash-put - manda arquivos para a lixeira.

Para mais informações leia o help de cada uma das variações do trash-cli.

    trash-empty --help
    trash-list --help
    trash-put --help


O problema agora é criar o hábito de usar o "trash-cli" em vez do bom e
velho "rm". Sim, porque nós instalamos o programa, mas por força do hábito é
bem provável que continuemos usando o "rm" sem nem notar.

Vamos então usar um truque para, digamos, desabilitar o comando "rm". O
truque consiste em, novamente, criar um alias. Mas antes disso vamos falar
de comentários no bash (com poucos ajustes todas essas dicas funcionam em
ourtos SHELLs).

Um comentário no bash inicia com #. Rode o seguinte comando direto do
terminal:
    # echo 'Hello, world.'
Essa linha não vai executar nada. É um comentário apenas.
Tente esta outra:
    echo 'Hello, ' # world'.
O echo acima só vai mostrar "Hello, ". O resto da linha é comentário.


Então, a ideia é criar um alias que comente o "rm". É fácil:
    
    alias rm='# rm'

Pode colocar o alias no ~/.bashrc e rodar "source ~/.bashrc". A partir de
agora, toda vez que você digitar "rm", ele simplesmente nem sequer será
executado, pois agora ele foi "comentado". No então, há alguns pontos a
serem considerados:

   1. Se você executar outro SHELL a partir do shell que contém o alias, o
      outro shell não vai herdar o alias, portanto, "rm" desse outro shell
      vai funcionar normalmente.

   2. IMPORTANTE: você executou essas operações no terminal como usuário, e
      configurou o ~/.bashrc em nível de usuário. A conta do ROOT continua
      com as configurações default. Como o ROOT é um usuário ainda mais
      crítico no sistema, considere colocar essas configurações no
      /root/.bashrc.

================================================================================
Anúncios

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.

Xdefaults VS Escape Sequences, Bash – Cores do Prompt

Posted in Bash, Dicas, Linux by Fernando Basso on 27 de dezembro de 2011

Leia todo o texto antes de tentar configurar algo. Algumas coisas que você ler mais no início do texto fará sentido quando se juntar com conceitos explicados mais adiante.

A intenção deste post não é mostrar TUDO sobre configuração do prompt do bash propriamente dito, mas sim mostrar a relação que tem as cores do terminal/prompt com as sequências de escape que usamos para configurar o prompt, pois sem essa noção, ficamos tentando configurar as cores “às cegas”. Esse tutorial funciona para o xterm, mas os conceitos são os mesmos para configurar outros emuladores de terminal.

Quando queremos configurar o prompt do Bash, usamos sequências de escape como:

    '\033[31m'
    

Faça um teste:

    echo -e "\033[31m Hello, World."

\033[ significa que estamos iniciando uma sequência de caracteres que não serão imprimidos, ou seja, inicia a sequência de escape. O próximo número (31, no exemplo) indica a cor que queremos imprimir, seguido de “m“, que termina a sequência de escape. O que vem em seguida é o texto que queremos realmente mostrar.

A parte numérica que determina a cor do texto pode indicar que queremos o texto em negrito, para isso, a sintaxe fica assim:

    echo -e '\033[31;1m Hello, World." # Note o ";1".

Ou seja, aquele 31;1, onde 31 é a cor, e 1 habilita o negrito. O número que especifica a cor e o número que habilita o negrito devem estar separados por ponto e vírgula (;). Mas agora vem a questão: 31 é qual cor? Aí é que entra o arquivo ~/.Xdefaults ou ~/.Xresourses.

No ~/.Xdefaults temos entradas como as do exemplo abaixo:


    ! Black, \033[30m
    XTerm*color0: #000000
    ! DarkGrey, \033[30;1m
    XTerm*color8: #BABDB6

    ! DarkRed, \033[31m
    XTerm*color1: #FF6565
    ! Red, \033[31;1m
    XTerm*color9: #FF8D8D

No ~/.Xdefaults usamos cores que vão de color0 até color15. As cores do color0 a color7 são cores normais, e de color8 até color15 são as cores em negrito, ou brilhosas.

Aqui temos um conceito importante. Note nos comentários (linhas iniciadas com !). Por exemplo, *color0 é a cor que será usada na sequência de escape \33[30m (cor normal), e a color8 será usada com a sequência \33[30;1m, ou seja, a cor em negrito. Continuando, color1 é usada pela sequência \33[31m (cor normal) e color9 é usada pela sequência \33[31;1m, a cor em negrito, e assim sucessivamente, até a color7 para cores normais, e color15 para os negritos.

Agora, configure as cores do xterm no ~/.Xdefaults da maneira que quiser, ou simplesmente copie as minhas (que pode modificar depois):

! ***** My Xterm Colors ***** ! {{{
! 1 to 7 are normal colors. 8 to 15 are the bright/bold ones.
XTerm*foreground: yellow
XTerm*background: #242424

! Black, \033[30m
XTerm*color0: #000000
! DarkGrey, \033[30;1m
XTerm*color8: #BABDB6

! DarkRed, \033[31m
XTerm*color1: #FF6565
! Red, \033[31;1m
XTerm*color9: #FF8D8D

! DarkGreen, \033[32m
XTerm*color2: green3
! Green, \033[32;1m
XTerm*color10: #C8E7A8

! DarkYellow, \033[33m
XTerm*color3: #EAB93D
! Yellow, \033[33;1m
XTerm*color11: #FFC123

! DarkBlue, \033[34m
XTerm*color4: #204A87
! Blue, \033[34;1m
XTerm*color12: #3465A4

! DarkMagenta, \033[35m
XTerm*color5: #CE5C00
! Magenta, \033[35;1m
XTerm*color13: #F57900

! DarkCyan, \033[36m
XTerm*color6: #89B6E2
! Cyan, \033[36;1m
XTerm*color14: #46A4FF

! LightGrey, \033[37m
XTerm*color7: #CCCCCC
! White, 0\33[37;1m
XTerm*color: #FFFFFF

! }}} Xterm ends here.

Para que as configurações entrem em vigor, execute o comando:

    xrdb ~/.Xdefaults

Feche e abra o terminal novamente. Lembre-se que isso funciona para o xterm. Não adianta usar o gnome-terminal (do gnome) ou o konsole (do kde). Agora sim estamos preparados para brincar com o prompt.

O prompt do bash é definido pela variável PS1 (tem a PS2 também, entre outras, que é usada quando continuamos um comando na próxima linha).

Vamos fazer uma configuração básica do prompt. Não precisa editar arquivo nenhum por enquanto, pois vamos fazer direto pelos comandos. Antes, porém, dê uma olhada nesta lista:

    \$ # Mostra o prompt de usuário '$', ou root '#'.
    \u # Mostra o username.
    \h # Mostra o hostname.
    \t # Mostra a hora (time).
    \d # Mostra a data (date).

Tem outros. man bash, na seção PROMPTING tem mais informações.

Digite o próximo comando, e veja como fica o prompt (não se preocupe, poi s essas alterações não são definitivas).

    PS1='\$ '

Agora tente este:

     PS1='\033[31m \$ '

Mais um:

    PS1='\033[31m\h@\u, \033[33m \s-v \033[0m\$'

Notou a diferença das cores? Vamos tentar com negrito (lembre-se, depende de como as cores foram configuradas no ~/.Xdefaults):

    PS1='\033[31;1m\h@\u, \033[33;1m \s-v, \033[0m\$ '

IMPORTANTE: Quando usamos uma cor, ela fica em vigor até sobrescrevermos ela usando outra. No final, temos que fazer a cor voltar ao modo padrão/default. Para isso usamos a sequência de escape:

    \033[0m

Aqui está uma configuração da minha variável PS1, juntamente com mais duas linhas, pois a minha PS1 depende dessas duas outras linhas:

    shopt -s checkwinsize # For hr='=='stuff to work.
    hr='============================================================================================================================================================='
    PS1='${hr::COLUMNS}\r\n\[\e[1;32m\]\s-\v, \[\e[0;32m\]\h@\u, \d \t \n\$PWD=\[\e[1;36m\]"\w" \[\e[1;37m\] \n\$ \[\e[1;37m\]'

Quem quiser tirar umas ideais, aqui estão minhas config filesno github.http://snipt.net/FernandoBasso/my-bashrc-dec-26-2011

Como eu disse no início, a intenção é mostrar a relação Xdefaults vs Escape Sequences. Tem vários tutoriais na web que tratam exclusivamente do prompt do bash. No entanto, nunca vi nenhum documento ou tutorial mencionar essa relação. Sem saber disso, ficamos configurando cores às cegas…

Descobri essa questão da relação Xdefaults/Escape Sequences perguntando no fórum do arch (em inglês), depois de levar as tradicionais broncas “vai ler no wiki”, ou “RTFM”. Ou seja, o pessoal adora assumir que os ‘aprendizes’ não gostam de ler e querem respostas prontas. PS: eu tinha lido metade da web tentando aprender mais sobre isso, e no wiki do arch também não menciona isso. :)

May the force be with you. Always.

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: , , ,

Restaurando o Gnote no tray (bandeja) tint2

Posted in Dicas by Fernando Basso on 17 de novembro de 2011

Restaurando o Gnote no tray (bandeja) tint2

Depois de um upgrade, o tint2 parou de aparacer no
systray do meu tint2. Eu uso arch linux com openbox + titn2
e o gnome-settings-daemon pra ajudar no look and feel.
Menciono isso porque o tint2 tem configurações que são
manipuladas pelo deconf.

Pesquisando, encontrei uma solução, que é usar a linha
de comando para mexer no gsettings e “setar” a variável
use-status-icon para true.


gsettings set org.gnome.gnote use-status-icon true

Essa opção pode ser habilitada através do dconf-editor
também.

Aqui está o link do local onde achei a dica de como restaurar
or ícone do gnote no systray:

Uma coisa que eu me pergunto é: por que esse tipo de opção
não está no “preferences” do próprio aplicativo? Sem contar que
me parce mais natural as pessoas que usam um aplicativo deste tipo
queiram ele lá no systray, pois assim é fácil ler ou adicionar novas
anotações ou lembretes. Que bom que há uma maneira (escondida) de
restaruar o ícone. :)

May the force be with you. Always.

Shutdown No Openbox

Posted in Dicas by Fernando Basso on 25 de agosto de 2011

O Arch Linux é uma distribuição que gosto muito. Leve! Totalmente customizável. Nada vem ‘pronto de fábrica’. Você praticamente faz ela pra você do jeito que você quer. Não vem com gnome nem kde nem nada por padrão.

Esta distro realmente segue a filosofia KISS ao pé da letra.

Gosto do openbox não só por ser lightweight, mas por causa do look-and-feel clean que ele tem. Contudo, ter que sair do openbox e virar root ou usar o sudo pra desligar ou reiniciar o sistema é meio chato. Depois de umas tentativas falhas, encontrei um jeito de conseguir reboot e shutdown no openbox sem precisar da senha do root. Eis aqui o que fiz:

1. Primeiro, instale o sudo:

su -c 'pacman --sync sudo'

2. Configure um grupo para poder rodar o shutdown e o reboot sem precisar de senha. Aqui, vamos configurar
o gruop users:

su -c 'visudo'

Adicione isto no final do arquivo, ou abaixo dos exemplos que já (porvavelmente) existem no arquivo:

%users ALL=NOPASSWD: /sbin/reboot
%users ALL=NOPASSWD: /sbin/shutdown

Salve o arquivo e feche. Se não sabe como fazer isto, aqui tem um pequeno tutorial de como mexer no arquivo /etc/sudoers.

3. Temos também que adicionar o nosso usuário de login ao grupo users. Vou dar o exemplo usando o meu usuário, que é ‘jeditux’:

su -c 'gpasswd -a jeditux users'

Obviamente, substitua ‘jeditux’ pelo seu usuário do sistema.

4. Faça logout. Não adianta só sair do X (modo gráfico). Tem que dar um logout e fazer login novamente.

5. Abra o arquivo ~/.config/openbox/menu.xml e adicione isto perto do fim do arquivo:(procure por entradas similares com Exit e/ou Logout e coloque depois delas):

<item label="Reboot"> <action name="Execute">
    <execute>sudo /sbin/reboot</execute>
 </action> </item>
<item label="Shudown"> <action name="Execute">
    <execute>sudo /sbin/shutdown -h now</execute>
</action> </item>

Salve e feche o arquivo.

6. Finalmente, dê um reload no openbox para que a nova configuração do menu entre em vigor:

openbox --reconfigure

Agora você deve ver ‘Shutdown’ e ‘Reboot’ no menu do openbox, e ser capaz de reiniciar e desligar o sistema sem precisar ficar digitando comandos e dando a senha do root. Qualquer dúvida, é só colocar nos comentários.

Gconftool-2 – Preferências e atalhos de teclado no Gnome

Posted in Dicas, Linux by Fernando Basso on 28 de julho de 2010

Básico

Com o gconf-editor podemos configurar qualquer coisa que
seja possível de ser configurada no Gnome, desde mostrar ou não os ícones no
Desktop, até reduzir o uso da CPU desabilitando os ícones dos menus, entre
várias outras possibilidades. Em algumas distros, como Arch Linux
ou Gentoo, o gconf-editor não vem instalado com o Gnome.
Pra quem não gosta ficar instalando coisas sem necessidade, ou simplesemente
prefere usar a linha de comando, pode usar o gconftool-2.

O gconftool-2 é uma interface em linha de comando usada para
os mesmos fins que o gconf-editor.

O repositório do GConf (sim, dizemos que o gconf tem um “repositório de
preferências”) é formado por um diretório, uma chave, e um valor para esta
chave.

Visualizando as opções

Para saber as configurações e possibilidades de um diretório, fazemos:

gconftool-2 --recursive-list <diretório>

Por exemplo:

gconftool-2 --recursive-list /apps/nautilus/desktop

Ou

gconftool-2 --recursive-list /apps/nautilus/desktop | grep trash
trash_icon_name = (no value set)
trash_icon_visible = true

apps/nautilus/desktop é o diretório.
trash_icon_visible é a chave.
true é o valor da chave (neste caso, um valor booleano).

Alguns exemplos da configuração das preferências

Geralmente, configuramos valores booleanos, ou strings. Vamos aos exemplos.

Para mostrar (ou não) o ícone da lixeira no Desktop, usamos um valor booleano:

gconftool-2 set /apps/nautilus/desktop/trash_icon_visible --type boolean 'false'

Troque false para true (ou vice-versa), e observe o resultado.
Você pode habilitar ou desabilitar outros ícones no Desktop, além deste do
exemplo. Para saber as possibilidades faça:

gconftool-2 --recursive-list /apps/nautilus/desktop

Uma coisa que está muito em pauta na data deste post, é o fato de o Ubuntu
10.04 vir com os botões da barra de título no lado esquerdo. Pra mudar para o lado direito, basta fazer:

gconftool-2 --set /apps/metacity/general/button_layout \
  --type string 'menu:minimize,maximize,close'

IMPORTANTE: Esta barra invertida (\) nada mais é do que um caractere especial que permite continuar um comando muito comprido na linha seguinte. Por exemplo,
fazer:
ls –help é o mesmo que fazer:
ls \
–help

NÃO deixe nenhum espaço depois da barra invertida (backslash).

Você poderia também, por exemplo, colocar o ‘close’ no lado do ‘menu’:

gconftool-2 --set /apps/metacity/general/button_layout \
  --type string 'close,menu:minimize,maximize'

Mudar wallpaper:

gconftool-2 --set /desktop/gnome/background/picture_filname \
  --type string '/path/to/wallpaper'

Mostrar o ‘path’ em modo texto no nautilus:

gconftool-2 --set /apps/nautilus/preferences/always_use_location_entry \
  --type boolean true

Mudar wallpaper:

gconftool-2 --set /desktop/gnome/background/picture_filename \
  --type string 'Pictures/Backgrounds/my_gray_background.jpg'

Você já notou que o menu ‘Sistema’ não tem ícones (ao contráio do ‘Aplicações’ e ‘Locais’) ? Se quer ícones aí também, faça:

gconftool-2 --set /desktop/gnome/interface/menus_have_icons \
 --type boolean 'true'

Atalhos para rodar programas

Uma das coisa mais legais, é criar atalhos de teclado para abrir nosos
programas mais usados. Assim não é necessário ficar indo nos menus e sub-menus, ou dar Alt-F2 e dititar o nome do programa.
1. Primeiro, você configura uma atalho em /apps/metacity/global_keybindings.
2. Depois, configura um comando para aquele atalho.

Vamos visualizar os respectivos diretórios de chaves/valores primeiro, para
termos uma ideia. Rode os dois comandos, um de cada vez, e analize a saída.

gconftool-2 --recursive-list /apps/metacity/global_keybindings
gconftool-2 --recursive-list /apps/metacity/keybinding_commands

Vou exemplificar com os atalhos que eu mais uso. Lembrando que a tecla
windows, é entendida pelo gconf/gnome como Mod4. Então, os nossos atalhos
serão conseguidos quando seguramos a tecla windows em conjunto com outra
tecla, como Win+f, Win+g ou Win+1.

Abrir o Firefox:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_1 \
  --type string '<Mod4>f'
  gconftool-2 --set /apps/metacity/keybinding_commands/command_1 \
  firefox

Abrir o Opera:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_2 \
  --type string '<Mod4>o'
  gconftool-2 --set /apps/metacity/keybinding_commands/command_2 \
  opera

Abrir o xterm:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_3 \
  --type string '<Mod4>x'
gconftool-2 --set /apps/metacity/keybinding_commands/command_3 \
  --type string 'xterm -name xterm-Dejavu -geometry 87x17+0-0'

Este exemplo para o xterm depende da configuração do ~/.Xdefaults.

Abrir o gnome-terminal:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_4 \
  --type string '<Mod4>t'
gconftool-2 --set /apps/metacity/keybinding_commands/command_3 \
  --type string 'gnome-terminal --geometry 87x17'

Abrir o Nautilus:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_5 \
  --type string '<Mod4gt;h'
gconftool-2 --set /apps/metacity/keybinding_commands/command_5 \
  --type string 'nautilus'

Abrir o gvim:

gconftool-2 --set /apps/metacity/global_keybindings/run_command_6 \
  --type string '<Mod4>g'
gconftool-2 --set /apps/metacity/keybinding_commands/command_6 \
  --type string 'gvim'

Abrir o alltray:
Aqui está minha configuração do gvim.
Agora você já é capaz de de criar seus próprios atalhos de teclado.

Atalhos para mudar de Desktop

Finalmente, uma coisa que uso muito, são dois atalhos para mudar para o
desktop virtual 1 e 2.

gconftool-2 --set /apps/metacity/global_keybindings/switch_to_workspace_1 \
  --type string '<Mod4>1'
gconftool-2 --set /apps/metacity/global_keybindings/switch_to_workspace_2 \
  --type string '<Mod4>2'

Eu não sou um expert do Gnome. Desculpem-me por quaisquer erros.
Espero que isto seja útil. May the force be with you. Always.