Minha mais nova experiência foi com um “invalid multibyte char (US-ASCII)” quando eu executava um script em Ruby 1.9.2:

i18n.rb:2: invalid multibyte char (US-ASCII)

Na minha jornada para tentar solucionar o problema acabei encontrando um excelente artigo do troelskn: Character Sets / Character Encoding Issues, que explica muito sobre encoding e como contornar problemas com charset em browsers. Realmente vale a pena dar uma olhada.

Embora o artigo do troelskn me desse base teórica, não me auxiliava com o problema específico: Dizer ao interpretador Ruby 1.9.2 que eu estou usando UTF-8 (e não aquela coisa atrasada do US-ASCII – Aliás, ainda não entendi o motivo do Matz não usar UTF-8 como encoding padrão… mas enfim…).

A solução só foi encontrada num fórum do dreamincode, pelo Erik Price, com uma inserção de meta-tag de comentário que me lembra os hints do oracle e, tirando a bizarrice que é colocar meta-tag em código-fonte, serviu bem ao propósito: Fez o interpretador ler o código ruby como UTF-8!

O comentário que modifica o charset é:

# -*- coding: utf-8 -*-

E o script ruby fica assim:

# -*- coding: utf-8 -*- #especificado para caracteres UTF-8

print 'E não é que a Iñtërnâtiônàlizætiøn funciona???'

É isso!

Atualização

Encontrei a gem magic_encoding do m-ryan que inclui o comentário ‘mágico’ em todos os arquivos rb de um diretório e sub-diretórios.

Para usá-la, basta instalar a gem com:

gem install magic_encoding 

e depois entrar no diretório do projeto ruby e digitar

magic_encoding

Isso incluirá a meta-tag de comentário para o encoding UTF-8 em todos os arquivos .rb do diretório e subdiretórios.

Caso deseje outro encoding ou mais opções de uso, não esqueça de dar uma olhada na página do m-ryan no github.

Eu precisava logar a aplicação por módulo de negócio (por exemplo: integracao.log para o modulo que fazia a integração, persistencia.log para o modulo que se encarregava da persistência). Porém, certos pacotes que eram utilizados por vários modulos do sistema (por ex: o módulo de utilitários). Por isso, meu log não poderia ser baseado na classe (assim como é o logger padrão do java ou o log4j), eu teria que baseá-lo na instância.

Não encontrei uma forma de resolver isso no log4j (talvez até exista, mas eu desconheço), então criei um logger minimalista que possui características muito similares ao Log4j.

SimpleLog

O SimpleLog foi criado para ser utilizado em instâncias, mas nada impede seu uso em classes, assim como o Log4j é utilizado.

Instanciação

O SimpleLog pode ser instanciado das seguintes formas:

• Direta, utilizando as configurações padrões:

Log log = new DefaultLog();

• Direta, utilizando configurações personalizadas:

LogConfig logConf = new DefaultLogConfig(
                   LogLevel.WARNING,
                   new RollingFileAppender(new DefaultLayout())
              );
Log log = new DefaultLog(logConf);

Layouts

Há 3 layouts disponíveis para o log:

• DateLayout: Um layout simples, que utiliza apenas a data e a informação de log
• DefaultLayout: Um log com informações úteis
• FullLayout: Um log extremamente detalhado (ele pode tornar sua aplicação mais lenta, por isso, utilize em situações específicas)

Appenders

Há 2 appenders disponíveis:

• ConsoleAppender: Loga tudo no console java
• RollingFileAppender: Loga tudo em arquivo, que pode ser configurado para rotacionar, ter tamanho máximo, separar por período, etc.

Exemplos de utilização

• Logar uma mensagem:

log.trace("Minha mensagem de log");

• Logar uma mensagem com Throwable:

log.trace("Minha mensagem de log", myException);

• Logar uma mensagem com format:

log.trace("Minha mensagem de log deu erro de %s: %s",
                  myException.getClass().getSimpleName(),
                  myException.getMessage()
     );

Há 6 níveis de log, que estão disponíveis como métodos:

1. trace: utilizado para log extremamente detalhado
2. debug: utilizado para log de detalhamento específico
3. info: utilizado para log de informações de processos e configurações
4. warning: utilizado para log de alertas
5. error: utilizado para log de erros nos quais a aplicação possa continuar executando outros processos sem problemas
6. fatal: utilizado para log de erros irrecuperáveis, nos quais a aplicação não tem condições de continuar a execução garantindo integridade

Download

O SimpleLog pode ser obtido no meu site do github.

CGLIB

Em poucas palavras, a CGLIB é capaz de gerar classes que implementam interfaces que as classes originais não implementavam, também pode estender classes, efetuando proxy. O melhor: tudo em tempo de execução!

Maiores detalhes sobre essa API podem ser vistos no site do desenvolvedor e também no ótimo artigo do Carlos Eduardo Gusso Tosin.

LogWrapper

Ao desenvolver o LogWrapper, tive sempre em mente a filosofia de “Logar tudo, de qualquer classe”.

LogWrapper é um pacote que torna mais fácil a tarefa de logar dentro de qualquer classe de qualquer pacote java (tanto seu quanto de terceiros), via reflexão, utilizando a API CGLIB.

Ele pode ser obtido diretamente do meu projeto no github.

Funcionamento

LogWrapper é capaz de encapsular uma instância específica, dando a ela a habilidade de logar tanto as chamadas de métodos (com seus respectivos parâmetros) quanto seu retorno.

Se o método logado disparar alguma exceção, essa também será capturada e logada, inclusive com o Stacktrace.

Exemplo de uso

ClassToTest t = LogWrapper.enableTrace(new ClassToTest(), log, Level.INFO);

List<String> myList = LogWrapper.enableTrace(new ArrayList<String>(), log, Level.INFO);
myList.add("It's a test");
myList.add("and another test");

[Thread[main,5,main]] java.util.ArrayList.add("It's a test")	  # add method call (with argument)
[Thread[main,5,main]] java.util.ArrayList.ensureCapacity(1)		  # ensureCapacity call (called internally by add)
[Thread[main,5,main]] return: [null]							  # return of ensureCapacity (void)
[Thread[main,5,main]] return: [true]							  # return of add (true)
[Thread[main,5,main]] java.util.ArrayList.add("and another test") # the same process again...
[Thread[main,5,main]] java.util.ArrayList.ensureCapacity(2)
[Thread[main,5,main]] return: [null]
[Thread[main,5,main]] return: [true]

Conclusão

Usar CGLIB é muito fácil, logo de cara já vi diversas coisas interessantes que dá para se fazer com ela.  Eu sempre ouvi falar que API’s que alteram o bytecode eram poderosas e muito úteis. Pude comprovar isso nesse exemplo que é bem prático e interessante.

Certa vez precisei criptografar uns dados simples para inserir numa coluna do banco de dados e fiquei frustrado com a dificuldade e a confusão que é implementar diversas criptografias diferentes, até que decidi criar um facilitador, para que eu pudesse criptografar e decriptografar sem precisar entrar em detalhes do uso de Cipher, geração de Keys, etc…

A filosofia principal desse projeto é: Facilidade de uso de criptografia

Tentei implementar algo que fosse o mais simples possível de usar e que ao mesmo tempo fosse útil, encapsulando muitas das criptografias mais usadas, tais como as criptografias simétricas e até criptografias assimétricas.

A lista de criptografias implementadas atualmente é a seguinte:

Simétricas:

1. AES
2. Blowfish
3. DES
4. DESede
5. PBEWithMD5AndDES
6. PBEWithSHA1AndDESede
7. RC2
8. RC4

Assimétricas:

1. RSA 1024 bits

Exemplo de uso do pacote Cryptografy com algoritmos simétricos

Criptografia

//Obtenho a fábrica de criptografia simétrica
SymmetricCryptFactory factory = SymmetricCryptFactory.getInstance();

//Escolho o algoritmo PBEWithMD5AndDES
SymmetricCrypter pbeWithMd5AndDes = factory.getCryptografy(SymmetricAlgorithm.PBEWithMD5AndDES);

//Gero a chave (posso carregar uma pré-existente também)
pbeWithMd5AndDes.generateKey();

//Criptografo (posso obter o valor cripografado tanto em string quanto em byte, para retornar string, utilizo Base64 no byte)
String encrypted = pbeWithMd5AndDes.encrypt("input");

//Obtenho a chave serializada (para poder descriptografar posteriormente)
byte[] key = pbeWithMd5AndDes.getSerializedKey();

Descriptografia

//Obtenho a fábrica de criptografia simétrica
SymmetricCryptFactory factory = SymmetricCryptFactory.getInstance();

//Escolho o algoritmo PBEWithMD5AndDES e passo a chave serializada obtida durante a criptografia
SymmetricCrypter anotherPbeWithMd5AndDes = factory.getCryptografy(SymmetricAlgorithm.PBEWithMD5AndDES, key);

//Descriptografo o conteúdo criptografado, pronto!
String decryptedAgain = anotherPbeWithMd5AndDes.decrypt(encrypted);

Exemplo de uso do pacote Cryptografy com algoritmos assimétricos

Criptografia

//Obtenho a fábrica de criptografia assimétrica
AsymmetricCryptFactory factory = AsymmetricCryptFactory.getInstance();

//Escolho o algoritmo RSA de 1024bits
AsymmetricCrypter rsa = factory.getCryptografy(AsymmetricAlgorithm.RSA_1024bits);

//Gero as chaves pública e privada (posso carregar pré-existentes também)
rsa.generateKeys();

//Criptografo e obtenho um objeto EncryptSet, com o conteúdo criptofrafado e
EncryptSet es = rsa.encrypt("input");
String encrypted = es.getContents();
String encryptedKey = es.getEncryptedKey();

//Obtenho a chave publica serializada (para poder descriptografar posteriormente)
byte[] pubK = rsa.getSerializedPublicKey();

Descriptografia

//Obtenho a fábrica de criptografia assimétrica
AsymmetricCryptFactory factory = AsymmetricCryptFactory.getInstance();

//Escolho o algoritmo RSA de 1024bits passando a chave pública obtida na criptografia
AsymmetricCrypter rsap = factory.getCryptografy(AsymmetricAlgorithm.RSA_1024bits,pubK);

//Descriptografo o conteúdo criptografado, utilizando a chave criptografada criada junto ao conteudo criptografado. Pronto!
String decryptedAgain = rsap.decrypt(encripted, encryptedKey);

Simples, não? Para quem se interessar no projeto e quiser testar, divulgar ou ajudar a desenvolver, baixe-o no GitHub clicando aqui.

A dica é simples, basta adicionar os seguintes sources no arquivo /etc/apt/sources.list:

deb http://us.archive.ubuntu.com/ubuntu/ karmic universe
deb-src http://us.archive.ubuntu.com/ubuntu/ karmic universe
deb http://us.archive.ubuntu.com/ubuntu/ karmic-updates universe
deb-src http://us.archive.ubuntu.com/ubuntu/ karmic-updates universe

Após isso, atualize a lista de pacotes e instale o ruby 1.9.1:

sudo apt-get update
sudo apt-get install ruby1.9.1-full rubygems1.9.1

Para facilitar, criaremos um link simbólico do ruby 1.9.1 para ruby:

sudo ln -sf /usr/bin/ruby1.9.1 /usr/bin/ruby

Pronto!

Devido a sua simplicidade, a experiência com gitosis se torna mais rica se utilizarmos outras ferramentas em conjunto, dependendo da necessidade.
Esse artigo demonstra os passos que fiz para instalar o gitosis, além de como contornar alguns problemas.

Instalação

Essa instalação foi feita no Jolicloud pre-beta 4 e deve funcionar com poucas ou nenhuma alteração em outras distros baseadas no Debian, tais como o Ubuntu.
Primeiro instalaremos os pré-requisitos:

ssh: para estabelecer conexão com o protocolo do git
git-core: pacote do git
gitk: (opcional) interface gráfica para o git, exibindo os branchs e o histórico de alterações do repositório.
python-setuptools: compilador python, necessário para instalar e executar o gitosis

sudo apt-get install ssh git-core gitk python-setuptools

Vamos criar um diretório de downloads apenas para nos mantermos organizados:

mkdir -p ~/downloads
cd ~/downloads

E baixar o projeto do gitosis se algum dos repositórios abaixo:

git clone git://eagain.net/gitosis.git

ou

git clone git://github.com/res0nat0r/gitosis.git

ou

git clone <a href="http://github.com/res0nat0r/gitosis.git">http://github.com/res0nat0r/gitosis.git</a>

OBS: tentei utilizar o caminho curto: sudo apt-get install gitosis, porém sempre que eu tentava acessar o gitosis era solicitada senha no ssh e eu não consegui resolver o problema. Por isso, atualmente não recomendo a instalação via apt-get.
Após o download do projeto, instale-o:

cd gitosis
sudo python setup.py install

Adicione o usuário git (usuário que será utilizado pelo gitosis para conexão via ssh – é utilizado no endereço do repositório.
Ex: git clone USUARIO_GIT://eagain.net/gitosis.git)

sudo adduser \
--system \
--shell /bin/sh \
--gecos 'git version control' \
--group \
--disabled-password \
--home /home/git \
git

Agora criaremos uma chave rsa para o usuário administrador (não é o git, mas sim o usuário linux que será utilizado para alterar as configurações do gitosis), neste caso, o próprio usuário atual:

ssh-keygen -t rsa

Em seguida passamos a chave pública criada para o gitosis utilizando o seguinte comando:

sudo -H -u git gitosis-init < ~/.ssh/id_rsa.pub

Para finalizar a instalação, temos que dar direito de escrita e leitura para o arquivo post-update (caso contrário, as alterações feitas pelo administrador não serão refletidas para o gitosis:

sudo chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

Configuração do servidor

Voltando ao nosso diretório de trabalho:

cd ~/downloads

Com o gitosis instalado, agora iremos acessar suas configurações. As configurações do gitorious ficam no repositório “gitosis-admin” que deve ser acessado via git com o comando:

git clone git@localhost:gitosis-admin.git
cd gitosis-admin

No repositório gitosis-admin há toda a configuração necessária para que o gitosis funcione corretamente. Nele há o arquivo gitosis.conf, que contém as configurações do servidor, grupos, direitos de acesso, etc e a pasta keydir, que contém a chave pública de todos os usuários que possuem permissão para acessar os repositórios do gitosis.

Olhando o gitosis.conf, vemos que a única configuração que há nele é a do usuário atual como administrador (obtido pela chave pública enviada ao gitosis-init na etapa de instalação)

less gitosis.conf

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = usuario@maquina

Vamos editar o gitosis.conf e adicionar mais algumas configurações, tais como habilitar o debug e inserir um novo grupo para um projeto. O debug servirá para que nós possamos entender melhor algum erro que possa ocorrer durante a instalação. No final do procedimento ele pode ser removido.

O grupo, chamado equipeAlpha, inicialmente possuirá direito de escrita no repositório myProject e terá como membro apenas o usuário jolicloud@vm (usuário da máquina local).

vi gitosis.conf

# Leia o arquivo example.conf no diretório do projeto gitosis para ver outros exemplos comentados
[gitosis]
loglevel = DEBUG
[group gitosis-admin]
writable = gitosis-admin
members = jolicloud@vm root@vm

##################################
###   GROUPS   ##########################
##################################
[group development]
writable = Repositorio2 ProjetoXpto MyProject MyJdbc JavaCommons
members = jolicloud@vm

[group rcaetano]
writable = RelationalDao RelationalDaoSample Cryptografy
members = jolicloud@vm

Após essas alterações, salve o arquivo e não esqueça de comitá-lo e o enviar de volta ao servidor gitosis:

git commit -am 'Adicionados grupos development e rcaetano'
git push

Com isso feito, o servidor já estará habilitado para aceitar os repositórios Repositorio2, ProjetoXpto, MyProject, MyJdbc, JavaCommons, RelationalDao, RelationalDaoSample e Cryptografy.

Dentro de cada grupo, há duas tags obrigatórias: writable e members.

A tag writable indiga quais repositórios podem ser alterados.

A tag members indica as chaves públicas dos usuários que podem escrever nos repositórios de writable. Note que as chaves públicas do arquivo não possuem a extensão “.pub”. Além disso, essas chaves devem estar no diretório keydir (mais detalhes sobre as chaves, na sessão abaixo).

Criando e usando um repositório

Voltando ao diretório de trabalho:

cd ~/downloads

Vamos criar um novo diretório para o repositório Cryptografy:

mkdir Cryptografy
cd Cryptografy

E vamos iniciá-lo:

git init

Agora que já temos nosso repositório, vamos adicionar o gitosis como servidor de origem (destino do git push):

git remote add origin git@localhost:Cryptografy.git

…Trabalhe normalmente no projeto…

Após trabalhar no projeto, adicione os arquivos no git e salve as mudanças.

git add .
git commit -am 'commit inicial'

Para só então enviá-lo ao servidor:

git push origin master:refs/heads/master

OBS: quando não há branch (o projeto acabou de ser criado), o primeiro push deve ser especificado como master. Após isso, os outros push’s podem ser feitos sem especificar a origem.

Adicionando novos usuários

A adição de novos usuários exige uma iteração maior entre o usuário e o administrador, pois antes que o administrador possa adicioná-los no gitosis, os próprios usuários deverão fornecer suas respectivas chaves públicas.

O procedimento para geração de chaves públicas de usuário é idêntico ao utilizado pelo administrador. Porém deve ser efetuado na própria máquina do usuário:

Linux:

No Linux, basta executar o seguinte comando:

ssh-keygen -t rsa

Após gerar suas chaves, os usuários deverão ir em seus respectivos diretórios ~/.ssh e enviar o arquivo de chave pública (id_rsa.pub) ao administrador, renomeando-as no padrão USUARIO@MAQUINA.pub para evitar conflito de nome.

Windows:

Se o usuário estiver no Windows, ele deverá instalar o Cygwin (http://www.cygwin.com/) seguindo o seguinte procedimento:

1. Baixe o cygwin na página HTTP://www.cygwin.com/
2. Execute-o e clique em avançar:

Clique me instalar pela internet e avance:

Configure para o diretório c:\cygwin para todos os usuários e avance:

Coloque os pacotes no diretório em c:\cygwin-pkg e avance:

Configure o Proxy e avance novamente:

Escolha qualquer mirror e avance:

Aguarde o download dos pacotes:

Após o download, abrirá a tela de escolha de pacotes do Shell. Nesta tela, procure e marque para instalação os seguintes pacotes: openssh, git, git-gui, gitk, git-completion, curl, cvsps, cvs e wget.

Os pacotes selecionados serão instalados…

Agora basta marcar os atalhos e concluir a instalação:

Após instalar o cygwin, execute-o e digite:

ssh-keygen -t rsa

Esse comando criará a pasta .ssh que contém a chave pública e privada. A pasta .ssh fica em ~/.ssh no cygwin e fica em C:\Documents and Settings\usuario\.ssh no Windows.

O usuário deverá enviar o arquivo de chave pública (id_rsa.pub) ao administrador, renomeando-as no padrão USUARIO@MAQUINA.pub para evitar conflito de nome.

Permitindo usuário no gitosis:

De posse das chaves públicas, o administrador pode adicioná-los no gitosis simplesmente as copiando para dentro da pasta keydir. Aqui, suponha que as chaves públicas foram copiadas na /tmp:

cd gitosis-admin
cp /tmp/rcaetano@cas165.pub keydir/
git add .

Com as chaves públicas copiadas, edite o gitosis.conf novamente para adicionar os novos usuários em seus respectivos grupos:

vi gitosis.conf

[group development]
writable = Repositorio2 ProjetoXpto MyProject MyJdbc JavaCommons
members = jolicloud@vm rcaetano@cas165

[group rcaetano]
writable = RelationalDao RelationalDaoSample Cryptografy
members = jolicloud@vm rcaetano@cas165

E publique as mudanças no gitosis:

git commit -am 'Adicionado rcaetano em development e rcaetano'
git push

A partir daqui, os usuários adicionados já podem acessar os projetos em suas respectivas máquinas apenas digitando:

git clone git@vm:MyProject.git

Sugestão:

Uma forma prática p/ envio de chaves públicas (porém pouco segura, utilize apenas para testes) é criar um usuário próprio p/ envio das chaves via ssh. Para isso, criamos o usuário tmp na máquina que contém o gitosis:

sudo adduser \
--no-create-home \
--shell /bin/sh \
--gecos 'usuario para transferencia de chaves publicas' \
tmp

Os usuários passariam as chaves utilizando o seguinte comando em suas respectivas máquinas:

scp ~/.ssh/id_rsa.pub tmp@local.server:/tmp/USUARIO@MAQUINA.pub

E finalmente, o administrador do gitosis poderia adicionar as chaves passadas (que se encontram na pasta /tmp) para o gitosis:

sudo mv /tmp/USUARIO@MAQUINA.pub ~/downloads/gitosis-admin/keydir/

e adicionar os usuários em seus respectivos grupos no gitosis.conf.

Erros comuns

ssh pede senha durante o git clone

Isso pode ocorrer se você instalou o gitosis utilizando:

sudo apt-get install gitosis

Não descobri o motivo, mas baixando o gitosis pelo git e instalando com o setup.py esse erro não ocorre.

gitosis não permite fazer push de um novo repositório mesmo após configurar o gitosis.conf

Esse erro pode ocorrer por esquecer de dar o push no projeto gitosis-admin ou por não haver permissão de escrita no arquivo post-update, no caso do seguindo problema, o comando abaixo deve ser executado no servidor do gitosis:

sudo chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

Preparando o Ubuntu

Primeiramente, vamos atualizar o sistema:

> sudo apt-get update
> sudo apt-get upgrade

Agora vamos começar a instalar os pacotes que são pré-requisitos e o git. Os pacotes essenciais são instalados da seguinte forma:

> sudo apt-get install build-essential zlib1g-dev libssl-dev libreadline5-dev
> sudo apt-get install curl sun-java6-jdk
> sudo apt-get install ruby rubygems

e os do git, assim:

> sudo apt-get install git-core git-doc git-svn git-gui gitk

Instalando e configurando o RVM

Com os pré-requisitos instalados, agora já podemos instalar o rvm e montar os ambientes rubies. Para isso, instale a gem do rvm:

> sudo gem install rvm
> /var/lib/gems/1.8/bin/rvm-install

Apos terminar a instalação do rvm, é necessário configurar o .bashrc. Para isso, execute o comando:

> sudo gedit ~/.bashrc

e insira o seguinte trecho no final do arquivo:

if [[ -s $HOME/.rvm/scripts/rvm ]] ; then
 source $HOME/.rvm/scripts/rvm
fi
export PS1='\w `/usr/local/rvm/bin/rvm-prompt i v` `git branch 2> /dev/null | grep -e ^* | sed -E s/^\\\\\*\ \(.+\)$/\(\\\\\1\)\ /`\[\033[37m\]$\[\033[00m\] '

Instalando os ambientes ruby

Nesse ponto é necessário reabrir o console (para atualizar o path) e instalar os ambientes (cada ambiente demora alguns minutos para ser instalado):

> rvm install ree
> rvm install 1.9.1
> rvm install jruby

Caso queira listar todos os ambientes suportados, utilize o comando:

> rvm list known

Com os ambientes instalados, execute o comando a seguir para instalar o rails em todos os ambientes de uma só vez (esse comando demora, aproveite para um cafezinho ):

> rvm gem install rails

Pronto! a configuração principal do ambiente esta finalizada. Comandos básicos para manipular os ambientes no RVM Para listar os ambientes instalados, use:

> rvm list

Para alterar o ambiente padrão, use:

> rvm [nome do ambiente] --default

Para trocar o ambiente ativo, use:

> rvm [nome do ambiente]

Uma descrição detalhada do uso do rvm pode ser encontrada aqui.

Instalando o Netbeans – Ruby (opcional)

Agora instalaremos a versão do Netbeans 6.8 para ruby. Para isso, acesse o site http://netbeans.org/downloads/ e faça download da distribuição para ruby (aprox. 91mb). Após o download, entre no diretório onde salvou o pacote do Netbeans via terminal e digite:

> cd Downloads/
> chmod 775 netbeans-6.8-ml-ruby-linux.sh
> ./netbeans-6.8-ml-ruby-linux.sh

Uma interface gráfica abrirá. Basta seguir os passos e aguardar a conclusão do processo de instalação. Com o RVM, rubies e Netbeans instalados, o ubuntu ja esta muito bem preparado para iniciarmos nossa exploracao em ruby e ruby on rails. Lembrando que ainda falta baixar suas gems favoritas e comecar a brincar! Uma sugestão de duas gems que ja usei e gostei bastante: memoize (aplica a tecnica de memoization, um tipo de cache para metodos) e hpricot (analisa texto, xml e html utilizando regex).

Caso esteja interessado na matéria completa, veja direto na fonte: Code » Posting Source Code.

Alex Gorbatchev criou a SyntaxHighlighter, muito interessante para postar códigos fonte formatado.

A WordPress.com não permite a adição de scripts externos, mas incorporou a funcionalidade do SyntaxHighlighter com a tag sourcecode .

Por exemplo, o código:

[sourcecode language="java"]
public Class HelloWorld{
   public static void main(String[] args){
      System.out.println("HelloWord!!");
   }
}
[/sourcecode]

Irá gerar a seguinte saída:

public Class HelloWorld{
   public static void main(String[] args){
      System.out.println("HelloWord!!"); System.out.println("HelloWord!!"); System.out.println("HelloWord!!"); System.out.println("HelloWord!!");
   }
}

Atualmente as seguintes linguagens são suportadas na tag language: actionscript3, bashcoldfusion, cpp, csharp, css, delphi, erlang, fsharp, diff, groovy, javascript, java, javafx, matlab, objc, perl, php, text, powershell, python, ruby, scala, sql, vb e xml.

Além disso, sourcecode possui os seguintes parâmetros opcionais:

• autolinks (true/false) — Torna clicáveis todas as URLs do código fonte.
• collapse (true/false) — Se verdadeiro, a caixa do código estará reduzida quando a página carregar, exigindo que o visitante clique para expandí-la. Útil para postar códigos fonte longos
• firstline (inteiro – 1) — Usado para mudar o número da linha inicial do código
• gutter (true/false) — Se falso, a numeração de linhas do lado esquerdo será omitida
• highlight (lista de números separados por vírgula) — enfatiza as linhas de código especificadas pela lista de números
• htmlscript (true/false) — Se verdadeiro, qualquer HTML/XML no código será enfatizado. É útil quando há outro tipo de código fonte misturado com HTML, tal como PHP dentro de HTML. Não funciona com algumas linguagens
• light (true/false) — Se verdadeiro, o gutter e o toolbar serão ocultados. Útil para exibir somente uma ou duas linhas de código
• padlinenumbers (true/false/integer) — Permite controlar o padding do número da linha. Verdadeiro é padding automático, falso não faz padding e o número irá forçar uma tamanho fixo de padding
• toolbar (true/false) — Se falso, a barra de ferramentas contendo botões utilitários que aparece quando o mouse passa pelo código não aparecerá
• wraplines (true/false) — Se verdadeiro, a quebra de linha será desativada. Ocasionando no aparecimento de uma barra horizontal na caixa do código quando houver linhas muito longas.

Como tenho bastante tempo disponível entre viagens para casa, adquiri o hábito de ler no trem-metrô e recentemente terminei de ler o ótimo livro Tudo o que você pensa, pense ao contrário da editora Intrínseca.

O livro é fantástico, uma verdadeira obra que incentiva a criatividade e a importância de ter coragem para inovar e assumir riscos. Com leitura agradável, formato de bolso e imagens belíssimas, o livro cativa e te impulsiona a “pensar ao contrário”.

Eu não conhecia as obras de Paul Arden mas confesso que depois de ler essa, estou interessado em outros livros do autor.

Sempre me interessei por ciência em geral, sendo a cognitiva uma das que mais me despertam interesse e ao ver a apresentação do Ramachandran, não pude deixar de escrever esse post (inaugurando o blog! hip hip Uhaaa!).

Na apresentação ele fala de uma descoberta impressionante: Estamos mais ligados mentalmente você pode imaginar! Confira AQUI!