É muito comum administradores de sistemas escreverem scripts para otimizar execução de processos, visualizar resultados de tarefas, monitorar estados dos serviços, etc, onde são geradas algumas saídas para o console. Muita vezes é importante destacar as saídas, como por exemplo, deixar em vermelho os erros, em verde os sucessos, etc, facilitando a análise dos resultados.

É uma situação que as seqüências escapes ANSI podem ajudar. Suportado nas maioria dos terminais, incluindo VT100 (o BTW, console da família de Windows NT não o suporta, mas existe um contorno que será explicado mais a frente).

Para o começar, vamos examinar a estrutura da seqüência de escape ANSI. A seqüência dever sempre começar com o símbolo ESC (código 27 da tabela ASCII) seguindo pela abertura de um ([) colchete. Há um ou mais número separado por (;) ponto-e-vírgula com uma letra na extremidade.

Não descreverei todos os códigos possíveis, qualquer um pode encontrá-los no Wikipédia ou Google. A seqüência com a letra ‘m’ na extremidade é usada mudar a cor do primeiro plano e a cor do fundo. Em geral é parecido com: ESC [31m, onde o 31 define a cor de primeiro plano (texto) como vermelha.

Segue abaixo uma tabela com códigos suportados na maioria dos terminais:

Como você pode observar na tabela, podemos definir a cor do texto e a cor de fundo separadamente ou combiná-las em uma única seqüência, por exemplo: ESC[1;33;44m - amarelo brilhante com fundo azul.

ATENÇÃO: Não esqueça de desativar todos os atributos antes de finalizar, senão todos os textos seguintes serão exibidos com os atributos que você acabou de definir, a não ser que essa seja sua intenção.

Chega de teoria, vamos a parte prática:

Utilizando o IRB vamos executar o seguinte trecho de código

#Imprimindo uma mensagem de sucesso em verde
puts "Importando categorias [ \e[32mOK\e[0m ]"
# Impriminido uma mensagem de falha em vermelho
puts "Importando tags [\e[31mFALHOU\e[0m]"

Como resultado você obterá:

Você poderá criar alguns helpers que facilitarão os trabalhos futuros, como exemplo:

def colorize(text, color_code)
   "#{color_code}#{text}\e[0m"
end
 
def red(text); colorize(text, "\e[31m"); end
def green(text); colorize(text, "\e[32m"); end
 
# Imprimindo uma mensagem de sucesso em verde
puts "Importando categorias [ #{green('OK')} ]"
# Impriminido uma mensagem de falha em vermelho
puts "Importando tags [#{red('FALHOU')}]"

Recomendo você utilizar desta forma para ser DRY, claro que talvez seja possível melhorar mais ainda, mas este não é objetivo deste post.

Como dito acima, o Windows não suporta seqüências escapes ANSI, mas você pode resolver isso lendo o artigo Command Interpreter Ansi Support, ou com as próprias facilidade do Ruby:

Primeiro instale o win32console:

gem install win32console

Agora adicione o código abaixo no inicio de seu script:

begin
   require 'Win32/Console/ANSI' if PLATFORM =~ /win32/
rescue LoadError
   raise 'Voce deve instalar o gem win32console para utilizar cores no Windows'
end

Pronto, a saída de seu script será colorida tanto no Windows como no Unix.

Para finalizar, veja a tabela completa com diferentes códigos, a qual você poderá usar em seus scripts:

A tabela acima pode ser obtida através do script:

#!/usr/bin/ruby
 
[0, 1, 4, 5, 7].each do |attr|
   puts '----------------------------------------------------------------'
   puts "ESC[#{attr};Texto;Fundo"
   30.upto(37) do |fg|
      40.upto(47) do |bg|
         print "\033[#{attr};#{fg};#{bg}m #{fg};#{bg}  "
      end
      puts "\033[0m"
   end
end

Fonte: kpumuk.info

Quer aprender uma das linguagens que mais tem crescido pelo mundo com apenas poucos anos de vida e com grande previsão de crescimento para o próximo ano, sem ter que gastar nada?

O site RubyLearning.com mantido por Satish Talim, está promovendo um curso gratuito de Ruby, totalmente online. O curso está em sua 3ª edição e até o momento deste post, já possuía mais de 715 inscritos.

O curso será ministrado através do Moodle, uma aplicação opensource para ensino a distância e tem início em 07 de janeiro de 2008. Para mais detalhes e para realizar sua inscrição, acesse a página do curso.

O pré-requisito é saber inglês e já possuir alguma base de programação.

Não vá perder essa excelente oportunidade!

Finalmente foi lançada a tão esperada versão 6.0 da plataforma Netbeans.

A plataforma vem ganhando destaque com diversas inovações, mas creio que a mais esperada desta versão é o suporte a linguagem Ruby, se tornando umas das plataformas mais sofisticadas no mundo Windows e Linux para desenvolvimento nesta nova e poderosa linguagem. Logicamente que grandes melhorias também vieram para Java e C/C++.

A nova versão é constituída dos seguintes pacotes:

• Java SE
• Web e Java EE
• Mobility
• Ruby
• C/C++

É possível realizar o download por pacote ou todos de uma única vez.

Para mais detalhes acesse o site da comunidade Netbeans.

O framework Ruby on Rails (RoR) tem ganhado cada vez mais adeptos entres os desenvolvedores Web 2.0, graças a sua alta produtividade e forte integração com AJAX (essencial para a Web 2.0).

A previsão de crescimento da linguagem Ruby no Brasil para 2008 é dobro em relação a 2007, aproximadamente 33% dos desenvolvedores, segundo levantamento da Evans Data, feito com 400 desenvolvedores no Brasil, China, Índia e Europa Oriental. Esse crescimento se deve em grande parte pela popularização do RoR.

Se alguém ainda não acredita no crescimento de RoR, pode verificar a grande lista de aplicações já desenvolvidas pelo mundo.

Com a popularização do framework, várias iniciativas começaram a surgir e uma muito interessante e promissora é o Heroku.

Heroku é uma plataforma online (beta) para desenvolvimento e hospedagem de aplicações em Ruby on Rails. Você só precisa de um Navegador para ter todo o ambiente de desenvolvimento em suas mãos.

A plataforma possui os seguintes recursos:

• Criação e edição online
• Importação de aplicações desenvolvidas fora do Heroku
• Compartilhamento de aplicações
• Desenvolvimento colaborativo
• Geração de código (generators e migrate)
• Rails console
• Sem necessidade de configuração e deployment

Para conhecer melhor cada recurso, veja os vídeos de demonstração.

Ficou interessado? Infelizmente vai ter que solicitar um convite e aguardar, pois estão limitando os acessos enquanto estiver em beta. A previsão para receber o convite é de 6 dias.

Logicamente você não terá todos os recursos de um ambiente de desenvolvimento off-line, mas com certeza é um grande iniciativa e será de grande utilidade para a divulgação de Ruby e RoR e para aqueles que desejam aprender, podendo estudar de qualquer lugar.

No último dia 09/jun, a equipe do JRuby anunciou o lançamento da versão 1.0. Essa versão tenta ser o máximo compatível com o Ruby 1.8.5, mas ainda existe trabalho a ser feito.

A equipe julgou que o projeto já havia chego a um estágio que poderia ser lançada para a comunidade começar utilizar. Para realizar o download, clique aqui.

Se você quiser conferir o quanto esta versão está compatível com o Ruby 1.8.5, veja o resultado de um excelente teste realizado pelo Fábio Akita, umas das pessoas mais ativa e importante da comunidade Ruby on Rails, também autor do livro “Repensando a Web com Rails”.

Um dia desses precisei escrever um script para manipular o registro do Windows para que eu pudesse altenar entre diferentes configurações do Rational ClearCase para acessar diferentes repositórios de diferentes servidores, e para agilizar meu trabalho utilizei a linguagem Ruby.

Para aqueles que gostaram da alternativa, veja abaixo como é simples essa manipulação, mostrarei as operações básica que também são as mais utilizadas. Para ficar mais didático, explicarei em parte e com pequenos exemplos.

A versão do Ruby para Windows possui a classe Win32::Registry, que permite justamente a manipulação do registro do Windows, e para utilizá-lo basta apenas escrever require ‘win32/registry’. Para enteder melhor os exemplos abaixo, vamos ver alguns conceitos importantes:

• Registro: é uma espécie de banco de dados, onde são armazenadas as informações sobre todos os programas instalados, estrutura de diretórios, informações do usuário, de drivers, etc
• Chave: é a estrutura básica do registro do Windows, são como pastas utilizada para a organização e armazenamento de valores. O Windows possui basicamente 5 chaves:
  • HKEY_CLASSES_ROOT – sua finalidade é manter compatibilidade com programas antigos, que rodam a 16 bits;
  • HKEY_CURRENT_USER – ela mostra somente informações do usuário atual do sistema, como configurações personalizadas, etc;
  • HKEY_LOCAL_MACHINE – esta é a chave mais importante do Registro, pois nela é que estão as informações sobre programas e hardware. Para se ter noção da importante desta chave, seus dados são guardados num arquivo chamado system.dat.
  • HKEY_USERS - no Windows é possível ter vários usuários num único computador e a função desta chave é guardar informações de cada um deles.
  • HKEY_CURRENT_CONFIG – contém configurações do usuário atual do computador relativas ao hardware.
• Valor: são como variáveis, que recebe um nome e armazenam valores que podem ser do tipo:
  • REG_SZ – Valor da seqüência
  • REG_BINARY – Valor binário
  • REG_DWORD – Valor Double Word
  • REG_MULTI_SZ – Valor de seqüência múltipla
  • REG_EXPAND_SZ – Valor de seqüência expansível

Com os conceitos básicos em mente, vamos aos exemplos:

Exemplo 1: Criando um chave e adicionando um valor
As variáveis chave, nome_valor e valor serão utilizadas em todos nossos exemplos.

require 'win32/registry'
 
chave = 'Software\TesteRubyRegistry'
nome_valor = 'VersaoRuby'
valor = '1.8.6'
 
#cria um nova chave
Win32::Registry::HKEY_CURRENT_USER.create(chave) do |regkey|
  #escreve o valor
  regkey.write(nome_valor, Win32::Registry::REG_SZ, valor)
 
  #para escrever o valor poderia também ser utilizado:
  #regkey[nome_valor, Win32::Registry::REG_SZ] = valor
end

No exemplo 1 chamamos a constante Win32::Registry::HKEY_CURRENT_USER com o método create, passando variável chave, o que significa que será criada a chave HKEY_CURRENT_USER\Software\TesteRubyRegistry.

A chave criada foi instaciada dentro de regkey, o qual chamamos o método write, passando o nome do valor (nome_valor), o tipo do valor (Win32::Registry::REG_SZ) e o seu contéudo (valor), para que seja escrito o valor VersaoRuby com o conteúdo 1.8.6.

Os demais exemplos seguem a mesma lógica e os detalhes estão comentados no próprio código.

Exemplo 2: Lendo um valor

#define o nivel de acesso da chave, apenas para leitura
nivel_acesso = Win32::Registry::KEY_READ
 
#abre um chave
Win32::Registry::HKEY_CURRENT_USER.open(chave, nivel_acesso) do |regkey|
 
  # o método Win32::Registry.read retorna um array,
  # contendo o tipo do valor e o valor atual
  tipo, valor_atual = regkey.read(nome_valor)
 
  #para retornar o valor atual poderia também ser utilizado:
  #valor_atual = regkey[nome_valor]
 
  #exibe o valor lido
  puts "Versao do Ruby: #{valor_atual}"
end

Exemplo 3: Modificando um valor

#definindo um novo valor a variável
valor = '1.8.5'
 
#define o nivel de acesso da chave para escrita
nivel_acesso = Win32::Registry::KEY_WRITE
 
#abre um chave
Win32::Registry::HKEY_CURRENT_USER.open(chave, nivel_acesso) do |regkey|
 
  #modifica o valor
  regkey.write(nome_valor, Win32::Registry::REG_SZ, valor)
 
  #para alterar o valor poderia também ser utilizado:
  #regkey[nome_valor, Win32::Registry::REG_SZ] = valor
end

Exemplo 4: Excluindo um valor

#define o nivel de acesso da chave para escrita
nivel_acesso = Win32::Registry::KEY_WRITE
 
#abre um chave
Win32::Registry::HKEY_CURRENT_USER.open(chave, nivel_acesso) do |regkey|
  #exclui o valor
  regkey.delete_value(nome_valor)
end

Exemplo 5: Excluindo uma chave

1ª forma

#true define exclusão recursiva
Win32::Registry::HKEY_CURRENT_USER.delete_key(chave, true)

2ª forma

#define o nivel de acesso da chave para escrita
nivel_acesso = Win32::Registry::KEY_WRITE
 
#abre a chave Software
Win32::Registry::HKEY_CURRENT_USER.open('Software', nivel_acesso) do |regkey|
  #exclui a chave TesteRubyRegistry
  regkey.delete_key('TesteRubyRegistry')
end

Sites de documentação Rails existem vários, mas o RailsBrain surpreende pela sua usabilidade. Fazendo uso de AJAX você poderá fazer buscas “live search” de métodos, classes e arquivos, expandir os exemplos de código-fonte, tudo isso sem a necessidade de recarregar páginas e com grande velocidade.

Se você gostou da idéia, acesse o site gotAPI, que você poderá obter o mesmo esquema de documentação para diversas outras linguagens e tecnologias.

Fonte: RubyInside

Durante a conferência MIX07 a Microsoft anunciou a criação do projeto IronRuby, uma implementação da linguagem Ruby para a plataforma .NET. O projeto IronRuby é similar ao que a Sun vem fazendo com o JRuby, mas não confundam o IronRuby com o Ruby/.NET Bridge, que somente conecta um interpretador Ruby com uma máquina virtual .NET.

Uma versão oficial do “Microsoft Ruby” vem sendo aguardado por membros da comunidade Ruby e uma indicação que isso estava acontecendo, foi John Lam, criador do Ruby.CLR, agora na Microsoft.

Fonte: InfoQ

Um interessante projeto acaba de ser lançado, chamado de Hackety Hack, é uma plataforma livre de ensino a programação em Ruby, para crianças, iniciantes em programação ou para aqueles que nunca programaram antes.

A ferramenta orienta os estudantes através de pequenas lições com explicações sobre cada parte do código implementado. Os códigos são executados e testados no próprio ambiente, permitindo também que os estudantes escrevam livremente suas aplicações e as salvem. Outro recurso interessante, porém ainda não disponível, é o compartilhamento de código.

Não é necessário instalar nenhum interpretador Ruby, pois a plataforma já vem com Try Ruby! embutido (também do mesmo criador do Hackety Hack).

Um dos pontos fracos da ferramenta é o idioma, pois atualmente está disponível apenas para o Inglês, mas creio que seja uma questão de tempo para suportar outros idiomas.

O download da versão beta está disponível apenas para Windows, mas versões para Linux e MacOS X estão sendo desenvolvidas.

Agora você não terá desculpas para não aprender a programar, principalmente em uma linguagem tão promissora como é Ruby!

Fonte: Ruby Inside

Hoje em dia as informações que podem alimentar um sistema ou website, são de vários formatos e fontes diferentes, exemplo: Sistema de Suporte a Decisão e aplicações Mashup e para demonstrar como isso é simples de se fazer usando Ruby, escrevi o exemplo abaixo baseado no artigo “Scraping IMDB with Ruby and Hpricot“.

Neste exemplo, serão extraidas informações sobre Ações do site Google Finance. O exemplo tenta mostrar algumas das maneiras utilizadas para se buscar as informações nas tags das páginas.

O pré-requisito para que a classe funcione é a biblioteca Hpricote, que é um parse HTML baseado na biblioteca HTree e JQuery, porém recodificado em C. A instalação pode ser feita pelo comando:

gem install hpricot

Vamos criar a classe Finance, que ao ser instanciada recebe o endereço da Ação que desejamos extrair as informações:

class Finance
   require 'rubygems'
   require 'hpricot'
   require 'open-uri'
 
   #inicializa as variáveis ao instanciar
   #a classe Finances
   def initialize(url)
      @hp = Hpricot(open(url))
   end
end

Para obter o símbolo da Ação consultada, vamos por exemplo extrair do link conforme a tela abaixo:

Para isso vamos criar o método symbol:

def symbol
   #procura pelas tags <strong><a href="http://www.lednerd.com/">...</a></strong>,
   #extrai o conteúdo e remove os caracteres \n
   @symbol = (@hp/"b/a").inner_text.gsub(/\n/,'')
end

Para obtermos o título da Ação, vamos extrair do cabeçalho H1 conforme tela abaixo:

Para isso vamos criar o método title:

def title
   #procura pelo tag <h1>...</h1>
   #e extrai o conteúdo
   @title = (@hp/"h1").inner_text
end

Para obtermos o índice da Ação, vamos extrair do SPAN conforme tela abaixo:

Para isso vamos criar o método index:

def index
   #procura pela tag <span class="pr">...</span>
   #e extrai o conteúdo
   @index = @hp.at("span[@class='pr']").inner_text
end

Para extrairmos o valor da variação da Ação, vamos extrair do SPAN conforme tela abaixo:

Para isso vamos criar o método change:

def change
   #procura pelas tags <strong><span class="chg">...</span></strong>
   #e extrai o conteúdo
   @change = (@hp/"b/span.chg").inner_text
end

Para extrairmos o percentual de variação da Ação, vamos extrair do SPAN conforme tela abaixo:

Para isso vamos criar o método percente_change:

def percente_change
   #extrai o html do <p id="market_data_div">...</p>
   market_data = @hp.search('#market_data_div')
   #procura pelas tags <span class="chg">...</span>
 
   #e extrai o conteúdo e remove os parênteses
   @percente_change = (market_data/"td/span.chg").inner_text.gsub(/[()]/,'')
end

O resultado final será como a classe abaixo:

class Finance
  require 'rubygems'
  require 'hpricot'
  require 'open-uri'
 
  #inicializa as variáveis ao instanciar
  #a classe Finances
  def initialize(url)
    @hp = Hpricot(open(url))
  end
 
  def symbol
    #procura pelas tags <b><a href=..>...</a></b>,
    #extrai o conteúdo e remove os caracteres \n
    @symbol = (@hp/"b/a").inner_text.gsub(/\n/,'')
  end
 
  def title
    #procura pelo tag <h1>...</h1>
    #e extrai o conteúdo
    @title = (@hp/"h1").inner_text
  end
 
  def index
    #procura pela tag <span class='pr'>...</span>
    #e extrai o conteúdo
    @index = @hp.at("span[@class='pr']").inner_text
  end
 
  def change
    #procura pelas tags <b><span class='chg'>...</span></b>
    #e extrai o conteúdo
    @change = (@hp/"b/span.chg").inner_text
  end
 
  def percente_change
    #extrai o html do <div id="market_data_div">...</div>
    market_data = @hp.search('#market_data_div')
    #procura pelas tags <td><span class='chg'>...</span></td>
    #e extrai o conteúdo e remove os parênteses
    @percente_change = (market_data/"td/span.chg").inner_text.gsub(/[()]/,'')
  end
end

Para testar a classe podemos criar o script abaixo e executá-lo:

require 'finance'
 
f = Finance.new("http://finance.google.com/finance?q=RIO")
 
p f.symbol
p f.title
p f.index
p f.change
p f.percente_change

Resultado:

O exemplo é simples, mas demonstra como poderiamos extrair informações de qualquer página e utilizá-las em nossas aplicações Web (com Ruby on Rails )

Outra poderosa biblioteca que faz uso do Hpricot é o scRUBYt!, mas falarei dela em uma outra oportunidade.

Este post está participando do concurso promovido pelo site Simples Idéias.