Feeds:
Posts
Comentários

For those using Gmate and having some issues, please fill them directly in Github  GMate project Issue Tracker.
If you have any suggestions or feature request, also post them there.

You can also contribute with project by finding and fixing bugs.. if you found a bug and Know how to fix it, you can fork the GMate project on Github, fix the bug, than ask me to merge your changes, I will be happy to apply your fixes after some sanity check.

If you are the owner of some plugin included in GMate, and want to help mantaining your plugin and maybe some other “unmaintained” plugin, please let me know, this should be the best scenario.

Thank’s for all people using, and help improving the GMate project.

DEB package for Gmate

I had debianized the Gmate Package, so now you can download and install it in your Ubuntu as a DEB package.

Note that it Depends of pyton-pywebkit that is included in Ubuntu 8.10. if you want to install in a previous Ubuntu release you will need to install Python Webkit Manually.

You can download the package direct from github.com

(See this post in english)

Eu acabei de corrigir alguns bugs no plugin Rails Footnotes e agora temos suporte completo para Ubuntu Linux  (Deveria funcionar em outras distros também, porém apenas usando o Gnome e o Gedit são suportados até agora).

Agora você poderá abrir qualquer arquivo listado nos stack traces exibidos no browser (Firefox) além de obter todos os demais benefícios dos Footnotes no final de suas páginas durante o desenvolvimento.

Veja os screenshots para ter uma idéia dos benefícios:

Footnotes Filters

Na imagem acima estamos mostrando a cadeia de filtros (Filter chain) do controller atual, mas podemos facilmente abrir o arquivo do controller, view, layout, estilos, javascripts direto no Gedit apenas clicando em um link, e, podemos também ver os Selects executados no banco de dados, log, Informações do ambiente, logs, routes e muito mais.

Footnotes Stack Trace

Na imagem acima estamos vendo um stack trace, então ao clicar em um dos links criados pelo plugin Footnotes, o Gedit já abre tal arquivo com o cursor posicionado corretamente sobre a linha onde o erro ocorreu.

Você pode fazer o download do plugin com suporte para linux aqui (Github master tree)

Para obter instruções sobre o processo de instalação, veja o arquivo README que está no pacote do plugin ou acesse a Página do projeto no Github.

Você pode também ler mais sobre este plugin no meu primeiro post sobre ele, e ainda assistir a um pequeno screencast mostrando sua funcionalidade.

(Ver este artigo em português)

I have just fixed some issues on Rails Footnotes plugin, and now we have full support for Ubuntu linux (this should work with other distros too, but only Gedit and Gnome are supported for now.

Now you can open any files listed on stack trace, and get all bennefits of Footnotes just bellow your pages during development.

Se the screenshots to get an Idea of beneffits:

Footnotes Filters

In image above we are showing the Filters chain of current controller, but we can easily, open the controller, view, layout, styles or javascripts files in Gedit by just one click in the link, and we can also see the database queries performed, log, Environment, Routes and much more.

Footnotes Stack Trace

In the image above we are seeing a stack trace, then we clicked on  a link created by Footnotes plugin, and Gedit just opened that file and switched the cursor to the correct line.

You can download the  plugin with linux support directly from here (Github master tree)

To get instructions about installation process point to README file on package or go to Footnotes Project Page on Github

You can also read more about this plugin on my first post about it (In Portuguese), and also watch a little screencast showing the plugin in action.

Este é um pequeno guia para iniciantes, que já tenham alguma noção do que é um controle de versão, caso você ainda não saiba veja adefinição da Wikipédia sobre Sistema de Controle de versão e também a definição de Sistema de Controle de Versão Distribuído (Em Inglês) que é o caso do Bazaar.

Quando precisamos de um controle de versão?

Sempre que queremos manter o histórico de alterações de arquivos, sejam eles código fonte de programas ou até mesmo documentos (aquelas várias versões do seu trabalho de conclusão de curso) entre outros arquivos, também é possível manter versões de arquivos binários, como fotos programas executáveis entre outros, porém para estes últimos alguns recursos não são possíveis, tais como ver as diferenças entre o arquivo na revisão 5 e 6.

Mas qual ferramenta usar?

Bem, existem várias e depende do molde que você quer trabalhar, mas eu posso recomendar hoje 3 ferramentas, e vou listar em ordem da mais fácil para a mais difícil de usar (na minha opinião), são elas: Bazaar, Git e Mercurial.
Presando pela facilidade de instalação e uso mas com todos os recursos dos demais e até mais algumas opções, minha opção foi o Bazaar.

Vou partir do princípio que você sabe instalar um software em seu sistema operacional, bem como utilizar um shell (“Promt de comando” para usuários windows). Todos os meus exemplos são feitos no Linux utilizando o gnome-terminal, sendo que para Windows alguns comandos do sistema operacional podem ser diferentes, mas os comandos do Bazaar são iguais.

Instalação

O Bazaar está disponível oficialmente para uma série de sistemas operacionais e também em forma de código fonte que “teoricamente” pode ser compilado em qualquer plataforma que rode Python.

  • Linux: Se já não estiver instalado você pode facilmente encontrar em seu gerenciador de pacotes, geralmente o nome do pacote é “bzr” e não bazaar:
  • Windows Siga as instruções de instalação (Em inglês) aqui ou clique aqui para baixar o diretamente o instalador da versão 1.9.
  • Mac OS X: Siga as instruções aqui (Em inglês).
  • Para outras plataformas e instalação via código fonte, veja mais informações aqui e aqui (Em inglês).

Se apresentando para o Bazaar

Antes de começar a controlar versão de coisas é interessante colocar sua identificação no Bazaar, para que ele possa “assinar” suas alterações nos arquivos, normalmente é utilizado o nome e email como identificação, portanto em um promt utilizando seus próprios dados digite:

  $ bzr whoami "Alexandre da Silva <simpsomboy@gmail.com>"

o Bazaar vai criar um arquivo de configuração (ou atualizar se ele já existir) incluindo sua identificação. para verificar qual a identificação você está utilizando atualmente ignore o segundo parâmetro e ele exibirá as configurações atuais:

  $ bzr whoami
  Alexandre da Silva <simpsomboy@gmail.com>

Controlando a versão de arquivos

Agora vem a parte interessante, vamos controlar a versão de alguns arquivos, para isso vamos criar uma pasta/diretório onde ficarão estes arquivos:

  $ mkdir arquivos
  $ cd arquivos
  $ mkdir adicionais
  $ touch teste1.txt teste2.txt teste3.txt adicionais/teste4.txt teste5.txt

(Usuários do windows não possuem o comando touch, e devem usar o Windows Explorer ou outra ferramenta para criar alguns arquivos texto vazios)

Até agora temos apenas uma pasta e um punhado de arquivos, vamos colocá-los agora no controle de versão:

  $ bzr init
  Standalone tree (format: pack-0.92)
  Location:
    branch root: .

Aparentemente nada foi feito, porém o Bazaar inicializou o diretório atual como um “branch” que nada mais é do que um local onde ficarão registradas todas as alterações realizadas nos arquivo pertencentes a ele. No Bazaar um branch é um diretório.

o próximo passo é adicionar os arquivos ao branch:

  $ bzr add
  added adicionais
  added teste1.txt
  added teste2.txt
  added teste3.txt
  added teste5.txt
  added adicionais/teste4.txt

Agora o Bazaar conhece os arquivos que ele deve manter o histórico, então vamos criar nossa primeira “revisão” dos arquivos existentes. Pense em uma revisão como uma foto do estado atual dos arquivos.

  $ bzr commit -m "Primeira versão"
  Committing to: arquivos/
  added adicionais
  added teste1.txt
  added teste2.txt
  added teste3.txt
  added teste5.txt
  added adicionais/teste4.txt
  Committed revision 1.

Como o Bazaar é um controle de versão distribuído não é necessário conectar a um servidor para enviar as alterações, todo o histórico de todos os arquivos ficam guardados dentro de apenas um sub-diretório especial chamado “.bzr” que fica no diretório raíz do branch.

Alterando seus arquivos

Vamos fazer algumas alterações e armazenar (commit) o que foi feito para o nosso branch.
Edite o arquivo teste1.txt em seu editor favorito, depois verifique o que foi feito:

  $ bzr diff
  === modified file 'teste1.txt'
  --- teste1.txt    2008-11-28 22:39:16 +0000
  +++ teste1.txt    2008-11-28 22:43:09 +0000
  @@ -0,0 +1,1 @@
  +teste teste teste

Armazene seu trabalho no branch:

  $ bzr commit -m "Adicionada primeira linha no arquivo teste1.txt"
  Committing to: arquivos/
  modified teste1.txt
  Committed revision 2.

Verificando o Log de alterações

Você pode ver todo o histórico do que foi modificado e quem modificou observando o log de alterações:

  $ bzr log
  ------------------------------------------------------------
  revno: 2
  committer: Alexandre da Silva <alexandre@exatisistemas.com.br>
  branch nick: arquivos
  timestamp: Fri 2008-11-28 20:44:12 -0200
  message:
    Adicionada primeira linha no arquivo teste1.txt
  ------------------------------------------------------------
  revno: 1
  committer: Alexandre da Silva <alexandre@exatisistemas.com.br>
  branch nick: arquivos
  timestamp: Fri 2008-11-28 20:39:16 -0200
  message:
    Primeira versão

Publicando seu trabalho em um servidor sftp

Existem várias maneiras de publicar um branch do Bazaar, mas uma das mais fáceis é utilizar um servidor sftp, se você tiver acesso a um você pode publicar seu branch da seguinte forma:

  $ bzr push sftp://seu.usuario@seu.servidor/~/arquivos
  Created new branch.

Criando sua própria cópia de um branch existente

Para trabalhar com os arquivos de outra pessoa você deve obter sua própria cópia (branch) para que possa trabalhar com os arquivos localmente em seu computador:

  $ bzr branch sftp://seu.usuario@seu.servidor/~/arquivos arquivos-copia1
  Branched 2 revision(s).

O Bazaar vai fazer o download de todas as revisões dos arquivos contidos no branch, além de uma cópia de trabalho contendo o estado atual dos arquivos.

Atualizando seu branch a partir de um branch remoto já modificado

Enquanto você modifica seus arquivos, os outros usuários também podem modificar os arquivos deles, podendo ser inclusive os mesmos arquivos, e neste último caso se for alterada a mesma parte do arquivo, há grande chace de você ter que resolver alguns conflitos, mas o processo é bem simples, mas em grande parte dos casos o Bazaar faz todo o trabalho para nós. Para atualizar nosso branch (cópia de trabalho) que já foi alterada, com um branch remoto que também já pode ter sido alterado, utilizamos o comando merge:

  $ bzr merge
  Merging from remembered parent location sftp://seu.usuario@seu.servidor/~/arquivos/
   M  teste2.txt
  All changes applied successfully.

Agora verificamos o que foi alterado:

  $ bzr diff
  === modified file 'teste2.txt'
  --- teste2.txt    2008-11-28 22:39:16 +0000
  +++ teste2.txt    2008-11-28 22:59:10 +0000
  @@ -0,0 +1,1 @@
  +editado editado editado

Estamos contentes com as alterações, vamos dar o nosso commit (armazenar nossas alterações) e em seguida publicar devolta para o branch remoto

  $ bzr commit -m "Merge a partir do branch principal"
  Committing to: arquivos-copia1/
  modified teste2.txt
  Committed revision 4.

  $ bzr push sftp://seu.usuario@seu.servidor/~/arquivos
  Pushed up to revision 4.

Como aprender mais

  1. Eventualmente estarei postando mais informações relacionadas aqui no blog.
  2. O Site oficial oferece uma ótima documentação, porém encontra-se em sua maioria em Inglês. http://doc.bazaar-vcs.org/latest/en/user-guide/index.html
  3. O próprio Bazaar pode lhe dizer o que fazer em alguns casos, para tanto consulte a ajuda de linha de comando:

Informações sobre a linha de comando do Bazaar

  $ bzr help

Informações sobre vários comandos do Bazaar

  $ bzr help commands

Informações detalhadas sobre um comando específico

  $ bzr help [comando]

Este artigo foi fortemente inspirado e pode ser considerado uma tradução parcial de: http://doc.bazaar-vcs.org/latest/en/mini-tutorial/index.html

Ruby on Rails 2.2 is out!

Depois de bastante espectativa, a Nova versão do Ruby on Rails (2.2) foi liberada para uso em produção.

Muitas melhorias foram incluídas nesta versão, como Thread Safety, Transactional Migrations, Internacionalização (i18n) e compatibilidade com a próxima versão do Ruby (1.9).

Saiba mais em: Site OficialRails GuidesO que Ha de novo, por Carlos Brando

Criando um Servidor Bazaar

Olá, hoje vou demonstrar como criar um servidor de controle de versão distribuído Bazaar. Para tanto temos basicamente 2 alternativas:

  1. Não fazer nenhuma configuração de Bazaar no servidor, apenas utilizar a estrutura existente.
  2. Instalar o Bazaar no servidor para prover o recurso do “Fast Server” que dá uma melhora na performance, ( em alguns testes que eu fiz baixar uma arvore de codigo direto do meu servidor para minha maquina tive um ganho de aproximadamente 20% )

Alguns protocolos de comunicação são suportados pelo Bazaar, são eles:

file:// => Este é o padrão, o protocolo utilizado quando você trabalha com branches no mesmo computador ou em um compartilhamento da rede no computador local, ou seja, se você fizer o seguinte:

$ bzr init meubranch
$ cd meu branch
hack
hack
hack
$ bzr commit -m "tudo pronto!"
$ cd ..
$ bzr checkout meubranch meubranch1

o último comando irá utilizar o protocolo file://

sftp:// => Este é o protocolo para usar em uma conexão segura ssh+ftp com o servidor, claro que se também é possível trabalhar localmente com este protocolo, mas é totalmente desnecessário. Este protocolo é o mais comum para servidores sem setup de Bazaar, pois fornece um bom nível se segurança. É necessário informar o usuário e senha do usuário do servidor para fazer operações com sftp, por exemplo:

bzr branch sftp://usuario@meuservidor/~/branch
usuario@meuservidor's password:_

Então você deve informar a senha do usuário para continuar a operação.
se não quiser entrar com a senha para cada operação é possível guardar as configurações de usuário e senha em um arquivo de autenticação, você pode ver mais osbre este procedimento aqui: http://doc.bazaar-vcs.org/latest/en/user-reference/bzr_man.html#authentication-settings

ftp:// => Este protocolo utiliza ftp, pode ser necessário informar um usuário e senha assim como no sftp a maior diferença é que os dados irão trafegar sem criptografia, o restante vale o mesmo do sftp.

http:// ou https:// => O Bazaar pode acessar qualquer branch que esteja visível via http ou https (com criptografia ssl), porém estes branches são apenas para leitura, é possível configurar o Apache por exemplo para permitir gravação em repositórios Bazaar sobre http, mas não é seguro e nem muito simples, então descarte a não ser que seja a última alternativa. Entretanto é um ótimo protocolo para repositórios publicados como somente leitura.

bzr:// => Este é o protocolo interno do Bazaar para utilizar em modo FastServer. Note que este protocolo sozinho não oferece segurança.

bzr+ssh:// => Este é o mesmo protocolo acima porém, utilizando um túnel ssh para trafegar os dados. É necessário possuir um servidor ssh instalado no servidor.

Servidor Sem Configuração.

Bem você vai precisar de um servidor linux instalado, de preferência o Ubuntu Server Edition 8.04 ou 8.10. As instruções de como instalar um servidor estão fora do escopo deste guia, mas, vá até o Google e digite “instalando ubuntu server”. Também é possível utilizar um servidor Windows mas eu particularmente não recomendo.

Considerando que o servidor já esteja funcionando, ele deve ter um servidor ssh com sftp rodando, e você ter acesso a ele é claro.
Pronto! Seu servidor Bazaar já está pronto para uso!:). Mas como isso? Não é preciso fazer configurações adicionais? De fato não, como o Bazaar é um controle de versão distribuído (4a Geração) que não precisa de nenhum setup no servidor.

Servidor com configuração.

Vou assumir que seu servidor usa Ubuntu ou Debian, ou alguma distribuição baseada em um dos dois. Você vai precisar de acesso root (sudo) no servidor e uma conexão com a Internet é claro :).
Para instalar o Bazaar no servidor execute:

sudo apt-get install bzr

depois deste comando o Bazaar já deve estar funcionando, para verificar digite:

$ bzr
Bazaar -- a free distributed version-control tool

http://bazaar-vcs.org/

Basic commands:
  bzr init           makes this directory a versioned branch
  bzr branch         make a copy of another branch

  bzr add            make files or directories versioned
  bzr ignore         ignore a file or pattern
  bzr mv             move or rename a versioned file

  bzr status         summarize changes in working copy
  bzr diff           show detailed diffs

  bzr merge          pull in changes from another branch
  bzr commit         save some or all changes

  bzr log            show history of changes
  bzr check          validate storage

  bzr help init      more help on e.g. init command
  bzr help commands  list all commands
  bzr help topics    list all help topics

Se o comando retornar algo similar ao texto acima, o Bazaar deve ter sido instalado corretamente.
Neste momento a parte de Bazaar já está pronta! Nossa mas só isso? Sim só isso :). Mas vamos colocar algo mais palpável para uso em produção.
Primeiro para não precisar encher o servidor de usuários, vamos criar um usuário que terá direitos de acesso aos branches, você pode usar o nome que você quiser para o usuário, em nosso exemplo vamos utilizar bzr.
digite o seguinte no servidor:

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

isso vai retornar algo como:

Adding system user `bzr' (UID 110) ...
Adding new group `bzr' (GID 118) ...
Adding new user `bzr' (UID 110) with group `bzr' ...
Creating home directory `/home/bzr' ...

o que estamos fazendo é criando um usuário e dando a ele um shell válido, para que o ssh funcione porém ele não poderá se logar no servidor usando qualquer senha. Ai você me pergunta, mas se não tem senha, como vamos fazer para autenticar no servidor? a resposta é, usando autenticação por ssh. Vou explicar aqui como fazer isso usando linux, para usar windows é possível fazer algo similar usando o PuTTY, mas o uso do PuTTY também está for do nosso escopo.
O primeiro passo é gerar uma chave pública e privada ssh, para fazer isso digite em um promt no seu computador cliente:

$ ssh-keygen

O comando vai pedir o local onde salvar a chave publica e privada, deixe o padrão, também vai pedir uma senha, que é opcional, se você não digitar nada ele não vai pedir nenhuma senha para efetuar a autenticação, entretanto eu recomendo que cada usuário coloque uma senha em suas chaves.
Bem, foi criada uma chave publica em ~/.ssh/id_rsa.pub e precisamos enviar esta chave para o servidor e colocar ela em um lugar que o usuário bzr conheça para que ele possa comparar a chave publica com a chave privada de cada usuário e efetuar a autenticação. Coloque o arquivo no servidor, vou exemplificar usando sftp:

$ scp ~/.ssh/id_rsa.pub usuario@servidor:id_rsa.pub

Agora acesse o servidor (via ssh ou outro) e lá iremos adicionar a chave publica que acabamos de criar para o cliente, na lista de chaves conhecidas do usuário bzr. já no servidor é preciso tornar-se o usuário bzr utilizando sudo e em seguida jogar o conteúdo da chave para a lista de chaves conhecidas do usuário bzr:

$ sudo su bzr
$ mkdir ~/.ssh (necessário apenas se o diretório ainda não existir)
$ cat id_rsa.pub >> ~/.ssh/authorized_keys

A sequência de comandos acima assume que você está no diretório home do usuário ao qual foi enviado o arquivo id_rsa.pub. Pronto!, a partir deste momento você já pode  utilizar o servidor e criar seus branches Bazaar nele, tanto usando sftp, quanto bzr+ssh (que é o mais recomendado).
Agora volte para sua máquina e vamos criar o nosso primeiro branch usando sftp (este não necessitaria ter o Bazaar instalado no servidor):

$ mkdir meubranch
$ cd meubranch
$ bzr init
$ touch arquivo1.txt
$ bzr add
$ bzr commit -m "branch teste"
$ bzr push sftp://bzr@servidor/~/meubranch

Isto vai publicar (push) as alterações de seu branch local para o servidor remoto via sftp.
para usar via bzr+ssh e ter um ganho de performance em algumas operações troque o ultimo comando por:

$ bzr push bzr+ssh://bzr@servidor/home/bzr/meubranch

Note que neste caso utilizamos o caminho completo para o branch no servidor, pois até o presente momento o ~ (til) que representa a pasta home do usuário ainda não é suportada pelo Bazaar, mas será em breve. Lembre que informar o camhinho do branch é necessário apenas no primeiro chechout/pull/push depois o caminho fica gravado. Mas se você resolver colocar os repositórios em alguma parte do servidor que seja muito difícil de digitar, como por exemplo “/var/projetos/vcs/bzr/branch” então você pode criar um link simbólico para a pasta raís, dentro do /.

sudo ln -s /home/bzr /bzr

isto vai criar um link com o nome bzr no sistema de arquivos raíz, então a o comando com a url vai ficar assim:

$ bzr push bzr+ssh://bzr@servidor/bzr/meubranch

Se não quiser publicar diretamente a pasta do usuário como /bzr, você pode (e deve) criar um subdiretório para os projetos dentro de “/home/bzr/projetos” e apontar o link simbólico para lá. (não esqueça de tornar-se(sudo su bzr) o usuário bzr antes de criar o diretório).

Toda a parte de configuração do servidor termina aqui. Claro que você pode criar seu servidor de outros modos, como por exemplo criando um usuário para cada desenvolvedor, etc, e aplicar suas próprias regras de segurança, mas isso é uma questão estrutural de cada projeto e/ou empresa.

foi comentado do protocolo bzr:// sem o ssh, para levantar um servidor desta natureza utilize o seguinte comando dentro de um branch:

bzr serve

Ele vai levantar um servidor somente leitura que ficará ouvindo maquina local (se você tiver o Ipv6 ativado, este comando vai dar um erro, então utilize bzr serve –port=127.0.0.1:4155 ) que é bastante útil quando queremos publicar um branch temporariamente com outro membro da equipe para que ele faça um merge por exemplo. se quiser que seja publicado para leitura e escrita utilize o parametro –allow-writes.

bzr serve --port=127.0.0.1:4155 --allow-writes

Para saber mais sobre o Bazaar acesse a seguinte página: http://doc.bazaar-vcs.org/latest/
Lá você vai encontrar a documentação completa de cada comando entre outras informações úteis.

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.