Dx7labs

Minha foto
Rafael Carvalho
Programador atuando na área de web com Ruby e PHP principalmente. Estudante de Ciência da Computação.
Visualizar meu perfil completo

terça-feira, 9 de março de 2010

Gist na linha de comando

Uma maneira simples e rápida de usar o Gist é usando a gem gist criada pelo defunk no github. Ela fornece um script pra ser usado em linha de comando que permite facilmente o envio de arquivos para o Gist.

Pra quem ainda é retardado não conhece o Gist, ele é uma maneira simples de compartilhar arquivos. Todos os arquivos do Gist são repositórios git, logo eles são automaticamente versionados, clonáveis e possível de fazer fork. Sem burocracia.

Pra usar a gem, tem que instalar:

$ sudo gem install gist

E pra usar basta apenas executar o comando gist dessas maneiras:

$ gist < file.txt
$ echo secret | gist --private # or -p
$ echo "puts :hi" | gist -t rb
$ gist script.py


Pra usar a sua conta do Github, é só fazer:

$ git config --global github.user "seu-github-username"
$ git config --global github.token "seu-github-token"


Pra descobrir o seu token, acesse sua conta no Github - http://github.com/account

Pra ver todas as opções, use:

$ gist -m

terça-feira, 26 de janeiro de 2010

Bash: executando o último comando

se você quer executar novamente o último comando completo, use:


prompt> !!

isso é útil, por exemplo, se você esqueceu de colocar o sudo na frente do último comando. assim é necessário apenas fazer:


prompt> apachectl stop
This operation requires root.

prompt> sudo !!
sudo apachectl stop

muito simples.

Bash: último argumento do comando anterior

se você executa, por exemplo:


prompt> ls -la /usr/bin/vi

e agora vc quer executar o /usr/bin/vi. é só executar:


prompt> !$

isso esquivale a fazer:


prompt> /usr/bin/vi

pois o !$ insere na linha de comando o último argumento usado no comando anterior.


outro exemplo:


prompt> ls -la /etc/my.cnf

agora vc quer ver o conteúdo do arquivo /etc/my.cnf?


prompt> cat !$

simples e fácil.

quarta-feira, 16 de dezembro de 2009

PHP - Números preenchidos com zeros a esquerda

e vc precisa de números preenchidos com zeros a esquerda, o PHP proporciona um jeito fácil de fazer isso:


 printf("%05d", -654);


Traduzindo a formatação 05d:


0 – preencher com zeros a esquerda, se o número de caracteres é inferior ao requerido;
5 – é o mínimo de caracteres requerido;
d – trata o argumento inteiro como um decimal respeitando seu sinal.


A função printf escreve a string formatada direto na saída padrão. Se precisar jogar essa string em uma variável, use sprintf da mesma forma.

terça-feira, 17 de novembro de 2009

Magento dando erro no login

Magento 1.3.2.4 está apresentando um erro bem estranho: não permite login através de qualquer browser, apenas no Safari e Opera funciona. No Firefox, no Chrome e no IE aparece um erro como se os cookies estivessem desabilitados, mas verificando estava tudo ok.

Pesquisei um pouco e encontrei uma solução no próprio fórum do Magento. Ele está com um bug em seu javascript que aparece quando o sistema está sendo executado no localhost.

Pra funcionar use http://127.0.0.1 em vez de http://localhost e tudo funciona “normalmente”. Isso pode ser feito na instalação, quando é escolhido o host ou, se já estiver instalado, no admin (com um dos browsers que funciona) em System ›› Configuration ›› Web, trocando tudo que for localhost por 127.0.0.1.

Coloquei o sistema em um subdomínio pra testar e não deu esse problema. Parece que é só com o localhost mesmo.

quinta-feira, 22 de outubro de 2009

MySQL: insert x insert ignore x replace

Alguns detalhes que muitas vezes são ignorados podem facilitar muito a vida no MySQL.


INSERT

Talvez o INSERT seja o segundo comando SQL mais conhecido, perdendo apenas para o SELECT. Ele insere novos registros em uma tabela existente. Caso o INSERT esteja tentando inserir um registro que tenha a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, ocorre um erro chamado erro de chave duplicada (duplicate-key error) e a execução é abortada.

Se esse erro ocorrer no meio de um script SQL, a execução do script é abortada.


REPLACE

Funciona exatamente como o INSERT, porém se o registro que está sendo inserido tem a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, esse registro já existente é apagado antes do novo ser inserido. E não ocorre erro.

INSERT IGNORE

A cláusula IGNORE altera um pouco o comportamento do INSERT:

Se o registro que está sendo inserido tem a mesma chave primária (primary key) ou índice único (unique index) de outro já existente na tabela, o INSERT IGNORE é ignorado e não ocorre erro.


Tentativas de inserir registros com valores inválidos não causam erros. Os valores serão ajustados para valores mais aceitáveis e inseridos. Warnings são produzidos, mas a execução não é abortada.

Resumindo

DELETE FROM `table`;
INSERT INTO `table` (`id`, `name`) VALUES (1, "Adriana");
INSERT INTO `table` (`id`, `name`) VALUES (1, "Pedro");
INSERT INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro INSERT será executado, o segundo dará erro e a execução será abortada (pois já foi inserido um registro com id = 1), o terceiro nem será executado.

Resultado:
+----+---------+
| id | name    |
+----+---------+
|  1 | Adriana |
+----+---------+


DELETE FROM `table`;
REPLACE INTO `table` (`id`, `name`) VALUES (1, "Adriana");
REPLACE INTO `table` (`id`, `name`) VALUES (1, "Pedro");
REPLACE INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro REPLACE será executado inserindo normalmente o registro como o INSERT faria. O segundo apagará o registro com id = 1 e adicionará outro registro com id = 1 sem erros. O terceiro REPLACE também será executado normalmente.

Resultado:
+----+--------+
| id | name   |
+----+--------+
|  1 | Pedro  |
|  2 | Rafael |
+----+--------+


DELETE FROM `table`;
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (1, "Adriana");
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (1, "Pedro");
INSERT IGNORE INTO `table` (`id`, `name`) VALUES (2, "Rafael");

O primeiro INSERT IGNORE vai inserir o registro exatamente como o INSERT sozinho faria. O segundo vai tentar inserir outro registro, mas como a chave está duplicada, será ignorado sem erros. O terceiro INSERT IGNORE também será executado normalmente.

Resultado:

+----+---------+
| id | name    |
+----+---------+
|  1 | Adriana |
|  2 | Rafael  |
+----+---------+

segunda-feira, 24 de agosto de 2009

git svn switch relocate


quando o repositório svn o qual foi feito o clone com o git-svn é movido, é preciso fazer alguns ajustes no git-svn pra poder continuar usando sem problemas. algo como um “svn switch—relocate” pra quem já está acostumado com o svn.
quem está acostumado com o git e conhece o arquivo .git/config pensa logo em alterar o valor da “url” em “svn-remote”. o problema é que somente isso não funciona. alguns passos devem ser seguidos:
- alterar o arquivo .git/config, com a nova svn-remote url do svn;
- executar um “git svn fetch” pra pegar a última revisão do svn. um detalhe importante: tem que vir alguma alteração do svn pra poder funcionar;
- alterar a svn-remote url para a url antiga;
- executar “git svn rebase -l” pra fazer um rebase local com as alterações que o fetch pegou. por isso que o fetch tem que trazer alguma alteração, senão o rebase não faz nada;
- alterar novamente a svn-remote url pra nova url do svn;
- executar “git svn rebase”. isso deve funcionar sem erros agora. e a partir daí já se consegue dar “git svn dcommit” sem problemas para o novo repositório svn.

Twittadas

Flickr