GMate Issues and Bug Reports
Posted by alexandre in Desenvolvimento, Gedit, Linux, Open Source, Ubuntu on junho 29, 2009
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.
The new is comming…. Ubuntu 9.04
Posted by alexandre in Linux, Open Source, Ubuntu, tecnologia on abril 17, 2009
For those who want to test, the RC1 is also available.
DEB package for Gmate
Posted by alexandre in Desenvolvimento, Gedit, Linux, Ruby on Rails, Ubuntu, rails, ruby, tecnologia on março 2, 2009
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
Rails footnotes suporte completo para linux
Posted by alexandre in Desenvolvimento, Gedit, Linux, Open Source, Rails Footnotes, Ruby on Rails, Ubuntu, rails, ruby, tecnologia on novembro 29, 2008
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:
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.
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.
Rails footnotes full linux support (footnotes for linux)
Posted by alexandre in Desenvolvimento, Gedit, Linux, Open Source, Rails Footnotes, Ruby on Rails, Ubuntu, rails, ruby, tecnologia on novembro 29, 2008
(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:
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.
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.
Controle de versão (Bazaar) em 5 minutos
Posted by alexandre in Bazaar, Desenvolvimento, Linux, Open Source, controle de versão, tecnologia on novembro 28, 2008
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 a definiçã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
- Eventualmente estarei postando mais informações relacionadas aqui no blog.
- 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
- 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!
Posted by alexandre in Desenvolvimento, Open Source, Ruby on Rails, rails, ruby, tecnologia on novembro 23, 2008
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 Oficial, Rails Guides, O que Ha de novo, por Carlos Brando
Criando um Servidor Bazaar
Posted by alexandre in Bazaar, Desenvolvimento, Linux, Open Source, Ubuntu, controle de versão, tecnologia on novembro 17, 2008
Olá, hoje vou demonstrar como criar um servidor de controle de versão distribuído Bazaar. Para tanto temos basicamente 2 alternativas:
- Não fazer nenhuma configuração de Bazaar no servidor, apenas utilizar a estrutura existente.
- 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.
Micro Tutorial de Bazaar
Posted by alexandre in Bazaar, Desenvolvimento, Git, Linux, Open Source, controle de versão, tecnologia on novembro 14, 2008
Conforme Prometido, vou reproduzir um tutorial idêntico ou pelo menos similar ao tutorial do Akita, só que utilizando o Bazaar ao invés do Git.
Recomendo altamente que leia o Artigo Original antes de prosseguir com a leitura, pois vou referenciar ele com bastante freqüência.
Pra deixar o ciclo completo eu vou baixar um projeto a partir do Launchpad que seria o “Equivalente” digamos assim do Github. o Akita utilizou com exemplo o Código do Merb Core, eu vou utilizar um branch do próprio Rails, que está disponível no Launchpad, não sei porquê alguém resolveu manter um branch bazaar dele lá no launchpad, mas, o branch existe e vou usá-lo como exemplo.
Para poder realizar operações de escrita em um projeto do lanuchpad obviamente você deve se cadastrar lá, e vai ter um ambiente bem similar ao do Github, com chaves publicas etc etc.
Para clarear uma das maiores diferenças entre o Bazaar e o Git é que, no Bazaar cada diretório é um branch, ou seja, se eu clonar o branch do rails por exemplo eu terei um diretório rails que é o meu branch, já o Git, o diretório é uma espécie de placeholder(Projeto) e você pode ter quantos branches quiser dentro do mesmo diretório.
Também não vou mostrar como instala o Bazaar, visto que há diferenças em cada sistema operacional, e nada que uns 5 minutos de Google não devam resolver, só para constar estou usando a versão 1.9 liberada em 07/11/2008.
O projeto rails no Launchpad fica na seguinte url:
https://launchpad.net/rails
Para obter o código fonte de um projeto no launchpad o Bazzar possui um recurso que já vem instalado por padrão (como um plugin), logo para baixar o projeto rails via Bazaar faça:
bzr clone lp:rails You have not informed bzr of your launchpad login. If you are attempting a write operation and it fails, run "bzr launchpad-login YOUR_ID" and try again. Branched 6711 revision(s).
ele reclamou ali que eu ainda não configurei minha identificação no launchpad,e eu não configurei mesmo 
.
ps: o processo acima vai demorar um pouco, assim como você fazer um clone do edge_rails do github também vai demorar, visto que ele baixa cerca de 41 megabytes.
Pronto, ao final do download você terá um branch contendo todo o histórico de revisões, assim como no git. no Bazaar o comando clone é um alias para o comando branch que tem por finalidade criar um novo branch a partir de outro, portanto clone, branch ou get fazem o mesmo efeito. Agora entre no diretório rails e digite:
bzr info Standalone tree (format: pack-0.92) Location: branch root: . Related branches: parent branch: http://bazaar.launchpad.net/%7Evcs-imports/rails/trunk/
Aqui são exibidas a formato atual do sistema de armazenamento, indica que estamos em uma arvore standalone, que estamos trabalhando no branch “root .” e mostra a referência do branch master que é de onde nós pegamos a nossa cópia, e para onde podemos depois enviar nossas alterações.
Bem, aqui temos um conceito diferente que, no Bazaar você pode criar repositórios compartilhados e não compartilhados. Nos compartilhados você inicializa um repositório, e cria um branch dentro dele, a partir dai você pode criar tantos branches quanto forem necessários dentro do repositório e todos os recursos serão compartilhados, ou seja vai ficar similar ao Git, já nos repositórios não compartilhados cada branch mantém todo o seu próprio histórico independente. Note que é possível converter de um para outro.
Manipulando branches locais.
Bom agora eu tenho uma cópia(branch) do branch remoto em meu computador, eu poderia sair alterando os arquivos direto dentro deste branch e no final mandar as alterações de volta, não há nada de errado com este modelo, mas seguindo o modelo do artigo do Akita, vamos criar um branch para de trabalho e vamos chamar de working, mas primeiro para ficar o mais similar possível vamos renomear o nosso branch que no momento se chama rails para master, assim os comandos vão ficar mais parecidos e em seguida criaremos o nosso novo branch.
mv rails master bzr branch master working Branched 6711 revision(s).
E primeiro comando é do Sistema Operacional estou movendo o diretório rails para o diretório master (renomeando)
Em seguida crio um novo branch a partir do meu master, note que como ele irá copiar TODAS as revisões para o novo branch vai demorar um pouquinho mais do que no git que é instantânea a criação de um branch, para que tenha um comportamento similar teríamos que usar um repositório compartilhado ao invés de standalone, mas acho que isso é uma preferência pessoal.
Eu poderia agora entrar no novo branch working e fazer minhas alterações lá, mas para ficar mais similar ao Git vou criar primeiro uma cópia de trabalho:
bzr checkout working copia cd copia bzr info Checkout (format: pack-0.92) Location: checkout root: . checkout of branch: /home/alexandre/tmp/bazaar/working
podemos perceber que agora estamos dentro de um checkout do branch working. Agora vamos fazer algumas alterações, aqui você pode fazer o que quiser que não vai estragar nada nem no repositório “principal” e nem no seu branch master, em seguida vamos ver o que foi alterado.
bzr status modified: Rakefile unknown: alexandre.txt
Bem os arquivos que já estavam no repositório aparecem na sessão modified ou removed, os arquivos que o ainda não estão lá, aparecem na sessão unknown (desconhecidos).
Para adicionar o arquivo novo que acabamos de criar, vamos usar o comando add assim como no svn ou git
bzr add alexandre.txt added alexandre.txt
caso varios arquivos tenham sido adicionados e você quer adicionar todos ao mesmo tempo (que seria o equivalente do git: git add . ) basta digitar:
bzr add
Aqui podemos notar outra diferença bastante grande entre o Bazaar e o Git, no Bazaar diretórios também são “versionados”, como se fossem arquivos regulares, então se criarmos um diretório vazio ele também será adicionado na árvore de versão, o que em muitos casos é util, para não termos que criar um arquivo .bzrignore dentro de uma pasta apenas para que a pasta seja “versionada”. Outra diferença é que o Bazaar ainda não possui uma opção interativa para o add (pelo menos eu desconheço), entretanto eu particularmente nunca senti a necessidade, pois mesmo utilizando o Git eu acabo dando normalmente um add . e um commit -a.
Agora com os novos arquivos adicionados podemos dar um commit, bem padrão igual ao svn e bastante similar ao git:
bzr commit -m "meu primeiro commit" Committing to: /home/alexandre/tmp/bazaar/working/ modified Rakefile added alexandre.txt Committed revision 6712.
No Bazaar não é necessário a opção -a para “adicionar” as alterações.
Observando visualmente:
Bom no nosso caso como estamos em no branch working e ele poderia continuar sozinho parece apenas uma alteracao linear.
outra coisa que podemos perceber aqui, é que o Bazaar possui uns nomes de revisão legíveis, o que facilita em alguns procedimentos, internamente o Bazaar controla por um sha1 único para cada revisão tal como no Git ou Mercurial.
Bom seguindo o artigo original agora acabamos de descobrir um bug no branch master, então teremos que mudar (switch) para o branch master, então fazemos:
bzr switch master Updated to revision 6711. Switched to branch: /home/alexandre/tmp/bazaar/master/ ls alexandre.txt ls: impossível acessar alexandre.txt: Arquivo ou diretório inexistente
bem, primeiro mudamos (switch) para o branch master, ou seja agora estamos em uma cópia de trabalho do branch master. agora vamos criar um branch chamado meufix para fazer nossas alterações.
bzr branch . ../meufix Branched 6711 revision(s).
Bem, o que fizemos?
estávamos em uma copia de trabalho do branch master (igual) entao vamos criar um branch novo “../meufix” baseado no branch (copia de trabalho) atual “.”, note que apenas o comando switch pode ser usado para trocar de branches sem precisar referenciar o diretório, mas agora estamos criando o branch “meufix” no diretório anterior ao atual da copia de trabalho.
agora ainda estamos no branch master, vamos mudar para o branch meu fix
bzr switch meufix Tree is up to date at revision 6711. Switched to branch: /home/alexandre/tmp/bazaar/meufix/
Não é possível criar um branch e trocar para ele em um comando só, a não ser que usássemos trapassa do Sistema Operacional, que seria mais ou menos assim.
bzr branch . ../meufix && bzr switch meufix
Bem, fizemos a nossa correção de bug e vamos dar o commit nas alterações:
bzr commit -m "minha correcao" Committing to: /home/alexandre/tmp/bazaar/meufix/ modified Rakefile Committed revision 6712.
Pronto, correçao feita em cima do branch master.
Merges
Bom, agora temos o branch master que não chegamos a tocar, temos o branch working onde estávamos trabalhando e fizemos um bugfix em um branch a partir do master. Que zona! mas agora temos que juntar tudo isso. Basicamente os branches working e meufix tem o mesmo ancestral, o master.
bem, vamos primeiro pegar o que foi feito no branch meufix e dar um merge.
bzr switch master Updated to revision 6711. Switched to branch: /home/alexandre/tmp/bazaar/master/ bzr merge ../meufix M Rakefile All changes applied successfully.
basicamente voltamos para o branch master e demos um merge nele com as informações do branch meufix, agora está tudo junto, podemos dar o commit para aplicar as alterações:
bzr commit -m "merge do meufix" Committing to: /home/alexandre/tmp/bazaar/master/ modified Rakefile Committed revision 6712.
vamos ver vizualmente o que aconteceu:
O master estava na revisão 6711, quando eu fiz o branch ele também estava nesta revisao entao fiz as alterações lá o branch meufix, e quando dei o merge novamente o número de versão ficou desta forma: [revisao pai][numero do branch][numero do commit], ou seja 6711.1.1. O numero do branch é gerado incrementalmente a medida que você executa o merge e deve ser lido da seguinte forma, Revisão 6711 branch 1 commit 1.
bom agora fizemos tudo que tinhamos que fazer e podemos apagar o branch meufix e voltar a trabalhar na nossa copia de trabalho do branch working.
bzr switch working Updated to revision 6712. Switched to branch: /home/alexandre/tmp/bazaar/working/ rm -rf ../meufix
Agora vamos trabalhar, mas, espere, fizemos uma correção no master e precisamos incorporar agora no nosso trabalho, mas, eu já estava no meio de uma alteração que ainda não está acabada, o que fazer?, a resposta é, guarda na prateleira e pega depois .
bzr shelve --- alexandre.txt 2008-11-14 16:57:16 +0000 +++ alexandre.txt 2008-11-14 19:18:20 +0000 @@ -0,0 +1 @@ +# Alexandre da Silva Shelve this change? (1 of 1) [yndisq?] (y): y
Status: alexandre.txt 2008-11-14 16:57:16 +0000 1 hunks to be shelved 0 hunks to be kept
Shelve these changes? [yrsiq?] (y): y Shelving to default/00: "Changes shelved on 2008-11-14 17:18:29"
shelf em Inglês significa prateleira, ou pilha, então empilhamos as nossas alterações em um lugar temporário para usar depois, agora vamos pegar o que estava no master e incorporar aqui.
bzr merge ../master M Rakefile All changes applied successfully.
pegas as alterações do master podemos agora pegar o que estávamos fazendo da prateleira e continuar nosso trabalho
bzr unshelve --- alexandre.txt 2008-11-14 16:57:16 +0000 +++ alexandre.txt 2008-11-14 19:18:20 +0000 @@ -0,0 +1 @@ +# Alexandre da Silva Unshelve this change? (1 of 1) [yndisq?] (y): y
Status: alexandre.txt 2008-11-14 16:57:16 +0000 1 hunks to be unshelved 0 hunks left on shelf
Unshelve these changes? [yrsiq?] (y): y Unshelving from default/00: "Changes shelved on 2008-11-14 17:18:29"
pronto, agora podemos continuar nosso trabalho e por fim dar um commit para aplicar as alterações.
commit -m "trabalho completo" Committing to: /home/alexandre/tmp/bazaar/working/ modified Rakefile modified alexandre.txt Committed revision 6713.
e Vizualmente o que aconteceu:
agora temos a revisao 6711.2.1 que é do nosso segundo branch a dar merge logo apos o merge do primeiro branch.
Bem, no artigo do Akita ele usiliza o comando rebase, que é basicamente similar ao merge só que as alterações são desfeitas e refeitas uma a uma, e o merge aplica as alterações sobre a copia de trabalho atual, o Bazaar possui o comando rebase também, que pode ser adicionado via plugin, mas como eu nunca utilizei, não sei se ele é estável ou mesmo se vai funcionar com minha versão do Bazaar que acabou de sair do forno, além do mais na prática o resultado final é o mesmo então aqui ele se torna desnecessário.
Para finalizar vamos agora dar o merge no nosso branch master que é de onde veio o código original, e por fim poderíamos enviar todas as alterações devolta para o projeto original.
bzr switch master Updated to revision 6712. Switched to branch: /home/alexandre/tmp/bazaar/master/ bzr merge ../working +N alexandre.txt M Rakefile All changes applied successfully. bzr commit -m "merge com working" Committing to: /home/alexandre/tmp/bazaar/master/ modified Rakefile added alexandre.txt Committed revision 6713.
e visualmente temos o resultado de todo o nosso trabalho:
pode parecer estranho que a versão 6711.2.1 veio depois da 6712, porém ele está mostrando a ordem temporal dos acontecimentos, além do mais fica fácil na visualização saber de onde cada revisão partiu. lembre-se que internamente as revisões são controladas igual ao git com hashes sha1.
Levando em consideração que cada um dos branches que eu criei funciona sozinho, eu posso manter cada um deles e criar outros a partir deles sem nenhuma restrição, inclusive se eu fizer um branch da minha cópia de trabalho, ele fará um branch do branch a que ela se refere no momento atual.
Para excluir um branch é só excluir o diretório que ele se encontra.
o Bazaar traz algumas funcionalidades interessantes que no Git é feito de forma diferente, vejamos:
Rename
bzr rename alexandre.txt alexandre2.txt alexandre.txt => alexandre2.txt
Sim, no Bazaar eu posso renomear um arquivo explicitamente e ele mantém a referência disso. no Git seria mais ou menos como criar um arquivo novo com o mesmo conteúdo e excluir o anterior, ou realizar aquele processo mágico de comparação de conteúdo que o Akita mostra no artigo dele.
Uncommit
bzr commit -m "renomeado" Committing to: /home/alexandre/tmp/bazaar/master/ renamed alexandre.txt => alexandre2.txt Committed revision 6714. bzr uncommit 6714 Alexandre da Silva 2008-11-14 renomeado
The above revision(s) will be removed. Are you sure [y/N]? y You can restore the old tip by running: bzr pull . -r revid:lexrupy@gmail.com-20081114194441-ei3fa5npeo7puc8q bzr status renamed: alexandre.txt => alexandre2.txt
Yes!, fiz uma coisa que não devia e dei um commit…. posso dar um uncommit e tudo volta como estava antes do commit. no Git você pode dar um hard reset no HEAD^1, mas o resultado não é exatamente o mesmo.
Conclusão
- Tudo foi feito offline com exceção do primeiro clone.
- Assim como no git eu tenho apenas 1 pasta .bzr no diretório principal do branch que controla tudo.
- Assim como no git podemos criar quantos branches quisermos para fazer nosso trabalho.
- Assim como no git o tamanho do diretório onde ficam guardados os arquivos com todas as revisões é praticamente do mesmo tamanho da própria cópia de trabalho.
- Assim como no git podemos trabalhar com um repositório svn remoto usando o bzr-svn e localmente usar todos os recursos do bazaar.
- E, por fim assim como no git eu escrevi este artigo enquanto digitava os comandos e dava uma olhada no blog do Akita para seguir mais ou menos o mesmo fluxo .
E a conclusão final é, seja qual for a ferramenta que você goste mais, Git, Bazaar ou Mercurial, use-a e aprenda a usar bem, pois elas podem economizar um monte de trabalho extra. Este artigo não tem o propósito de dizer que o Bazaar é melhor que o Git ou que o Mercurial, Apenas mostra que oferece os mesmos recursos. para aprender mais sobre o Bazaar visite o site, é a documentação da última versão em desenvolvimento, para outras versões olhe em um diretório acima e escolha a versão que você está usando.
Git Bazaar ou Mercurial?
Posted by alexandre in Bazaar, Desenvolvimento, Git, Linux, Mercurial, Open Source, controle de versão, tecnologia on novembro 14, 2008
Este artigo já estava na minha todo-list já faz algum tempo, visto que os projetos em que trabalho já estão utilizando controle de versão descentralizado desde o início de 2008, mas agora depois de reler o artigo do Akita resolvi tirar esta pendência do meu to-do.
Por quê mudar para um controle descentralizado?
Bom já faz algum tempo que o controle de versão descentralizado está em alta em detrimento às opções que acredito serem mais utilizadas ainda hoje que são o SVN e o CVS. Quero dizer que o SVN e outras ferramentas centralizadas que utilizamos solucionaram o problema para nossa equipe durante muito tempo, No início quando programava em Delphi era utilizado um controle de de versão integrado a IDE chamado FreeVCS, que depois se tornou o JediVCS, resolvia o problema e o workflow utilizado era o de dar o CheckOut do arquivo a trabalhar (isso travava o arquivo no servidor e ninguém poderia alterá-lo) fazia-se as alterações necessárias em em seguida executava o CheckIn aplicando as alterações no repositório principal e liberando o arquivo para outros desenvolvedores, Um bom começo.
Um dia precisamos tratar branches e coisas do gênero, e surpresa o nosso amigo Jedi não suportava (acho que ainda não suporta), então a solução foi migrar. O escolhido para a migração foi o SVN, provavelmente os descentralizados já existiam, mas os na época qualquer pesquisa no Google sobre controle de versão devolvia toneladas de links para SVN. Tudo bem até ai, e como nenhum usuário de Windows gosta de usar o promt de comando acabei desenvolvendo um plugin para o Delphi que se comportava mais ou menos como o JediVCS mas com o SVN, daí em diante muitos projetos no SVN, em seguida migração de plataforma (Hoje utilizamos Linux embora os servidores já fossem Linux desde a migração para SVN). Mas às vezes era necessário levar parte da equipe para outro local (longe dos servidores internos), geralmente no cliente, onde eram feitas alterações no sistema. A solução não era muito prática, fazer o setup de um servidor SVN temporário para o desenvolvimento no local, depois pegar as revisões gerar um diff gigante das alterações e aplicar no repositório na empresa e resolver os conflitos com o que os desenvolvedores internos fizeram neste meio tempo. Quando um dia decidi que precisávamos de um controle de versão onde pudéssemos realizar algum trabalho desconectados do servidor interno e depois fosse menos trabalhoso juntar tudo novamente, além de, manter o histórico de cada um dos commits realizados.
Foi então que comecei a minha jornada em busca de um controle de versão distribuído* é claro que fosse OpenSource, a lista é grande, onde podemos citar alguns como Codeville, Darcs, Monotone, Mercurial, Git e Bazaar além de mais alguns que não cheguei nem a pesquisar. Desta lista poucos minutos de pesquisa me levaram a considerar apenas o Bazaar o Git e o Mercurial, e fazendo alguns testes percebi que todos poderiam satisfazer minhas necessidades usando Linux. Então vamos às necessidades:
- Ser multiplataforma, afinal ainda tenho ainda hoje código fonte para manter em Delphi
. - Possuir um modo de converter meus repositórios Subversion.
- Ter uma curva de aprendizado pequena em relação ao SVN.
- Tivesse como integrar com alguma ferramenta estilo Trac ou Redmine.
Primeira Tentativa: Mercurial
No primeiro quesito, à primeira vista ele se encaixa pois grande parte do seu código é escrito em Python, tem um instalador para Windows (que não me parece ser oficial). Mas esperem, eu sou fissurado por usar a Ultima versão da ferramenta que o Desenvolvedor disse que está estável, logo, não me interessa muito usar o instalador da versão Windows, que na época dos meus testes instalava algo em torno de 0.9 e a versão oficial já era a 1.0 (Março de 2008). Bom escrito em Python pensei eu, vamos ao easy_install……
c:\easy_install mercurial...... bam!
Erro, claro, não havia um compilador C. vamos lá instalei toda a MingW, MSyS etc, easy_install denovo, compilou, instalou beleza!. Não, o comando hg não funciona, bom vamos la, eu crio um hg.bat que chama o script do mercurial, jogo na pasta Scripts e tudo certo…. Também não, mais algumas tentativas depois consegui rodar o hg e ter um resultado. Bom, pra mim morreu aqui, não quero uma coisa que cada vez que tenho que instalar tenha que… Instalar um compilador C que os meus desenvolvedores Windows nao vão ter na máquina e fazer mais um monte de gambiarras pra ter versão “featured” do sistema. Enfim o Mercurial possui uma ferramenta de conversão de repositórios SVN e outros e tem integração com algumas ferramentas, inclusive o Netbeans, que por sinal, Surpresa!, também não funciona no Windows mesmo tenho o Mercurial funcionando no promt instalado via easy_install, acho que só funciona se for via installer mesmo. A curva de aprendizado dele é bem grande se formos levar em conta que sempre temos usuários bitolados, ei, eu disse bitolados?, eu quis dizer “acostumados” com o SVN e seu set de comandos, mal e porcamente.
Já é um caos fazer as pessoas entenderem o conceito de controle distribuído.
Segunda Tentativa: Bazaar
Bom eu já estava desanimado mas tinha que continuar, Uma olhada no site, cheio de tutoriais e extensiva documentação, Boa! documentação parece pelo menos ser bem melhor que a do Mercurial, embora eu tenha encontrado muitos posts em blogs dizendo o contrário, então só posso supor que, se a documentação do Mercurial é boa, ela está bem escondida em algum lugar do Wiki deles, bom blames à parte, Já vi um instalador para Windows e… hum, vamos tentar do velho e bom modo…
c:\easy_install bazaar ...
E instalou sem nenhum erro… bom eu já tinha um compilador C instalado, seria por causa disso? Vamos desinstalar tudo e ver o que acontece. Após remover todas as parafernalhas do MingW e Cia Ltda e remover o egg** do Bazaar e tentar novamente… vamos lá…
c:\easy_install bazaar
E funcionou novamente!, bom o Bazar é completamente escrito em Python, o que explica a tamanha portabilidade. o comando bzr já saiu funcionando, e, por curiosidade vou até a pasta Scripts, e… lá está um arquivo bzr.bat mais ou menos como o meu workarround, porém, out-of-the-box. Tudo funcionando agora vamos ver uma ferramenta de conversão, na época utilizei o svn2bzr, que funcionou perfeitamente, mas não importou as tags e relações dos branches, mas a história Linear do Subversion veio funcionando 100%. Hoje tem o bzr-svn que é um plugin para trabalhar diretamente com repositórios svn utilizando o bzr, e esta sim importa as tags referências de branches, merges etc. Ok curva de Aprendizado… uma estudada na documentação e, show de bola, não só tem praticamente todos os comanos similares aos do SVN, como também permite trabalhar com vários Workflows, inclusive o modelo Centralizado igual ao SVN. Então uma pequena busca por integração com os issue trackers, e, existiam plugins para bugzilla, Trac, Redmine e outros. eu na época estava utilizando o Trac e estava pensando em migrar para o Redmine, boa oportunidade para dar uma testada nele… Instalei testei e funcionou 100%, inclusive com aqueles comandos de commit, do tipo: bzr commit -m “This commit fixes #772″ para fechar o ticket numero 772. Perfeito.
Terceira Tentativa: Git
Já mais contente mas minha jornada ainda não estava finalizada, uma pequena pesquisada e achei um instalador do Git para windows, que não era exatamente a última versão, mas vamos dar um desconto, o Git é escrito em uma carrada de linguagens, uma parte em C outra em Perl outra em Shell Script e por ai vai, fazer isso integrar, e pior, Funcionar no Windows não deve ser das mais fáceis tarefas. Bem, feita a instalação, ele instalou um shell bem similar ao do Cygwin que praticamente dá a leve sençassão de estar em um terminal Linux, e mais algumas ferramentas, ele utiliza o MingW, MSyS e outras bibliotecas para fazer a mágica de funcionar no Windows, Instalado fazer alguns testes, e gostei, segundo o próprio instalador e documentação afirma, alguns comandos não estão disponíveis pois falta ambiente***, mas para o uso diário geral show de bola. A curva de aprendizado….. hummm um pouco pior que a do Mercurial, porque por exemplo o comando checkout parece não ter nada haver com o que o SVN faz, embora para mim faça sentido, em fim, quando eu falei que era possível trocar de branch dentro da mesma cópia de trabalho com apenas um comando, ninguém entendeu nada, afinal totalmente fora deste planeta SVN. Continuando a conversão dos repositórios SVN também funcionou lindamente (bastante similar ao que hoje é o bzr-svn do Bazaar), e Integrou bonitinho com o Redmine, com uns pequenos probleminhas que não me recordo, mas, bastante usável.
Bom vejamos minha tabela de pontuação:
+----------+----------+-----------+----------+------------+ | |Multiplat |SVN/Import | CurvaApr | Integracao | +----------+----------+-----------+----------+------------+ |Mercurial | 5 | ?? | 7 | ?? | +----------+----------+-----------+----------+------------+ |Bazaar | 10 | 9 | 10 | 10 | +----------+----------+-----------+----------+------------+ |Git | 9 | 10 | 5 | 9 | +----------+----------+-----------+----------+------------+
Bom tinhamos um vencedor, agora vamos fazer algumas pesquisas e comparativos para ver o que o Povo acha… e, Blames**** está cheio!
bom na opinião geral e também por mim constatada, o Git é o Mais Rápido para a Maioria das operações, Seguido do Mercurial e por Último o Bazaar, mas a maioria desses artigos falam em 100000 arquivos de 10000 linhas cada um, e fazem um monte de testes com 10000 revisões etc… claro algo escrito basicamente em C seria obviamente mais rápido que algo escrito parcialmente em C e Python do que algo Totalmente em Python, mas nos meus testes de uso geral, a diferença de performance é praticamente irrisória, mesmo trabalhando com árvores grandes.
Agora vamos ver quem utiliza cada uma destas ferramentas. Bem o Git foi contruído pelo Linus para manter o Kernel do Linux, e fora o Kernel temos outros projetos grandes utilizando. Já o Mercurial tem o pessoal da OpenJDK do Netbeans entre outros projetos Java***** . O Bazaar quem principalmente usa é a Canonical para manter grande parte do Ubuntu, li em algum lugar (quando eu lembrar posto no final do artigo) que vai utilizar só o Bazaar para manter o Ubuntu, afinal de contas a Canonical é a mantenedora do próprio Bazaar, além dela alguns outros projetos grandes como o MySQL também utilizam.
Outras ferramentas que podem ser citada são os hostings Free que cada uma das ferramentas possui.
O Mercurial tem o FreeHg, que não cheguei a testar mas parece-me que é totalmente gratuíto e deve ser destinado a projetos OpenSource.
O Git tem o Gitorious e o mais recente Github, este último bastante utilizado por toda a comunidade Ruby On Rails, desde que o Próprio Rails foi hospedado lá, além de o próprio Github ser desenvolvido em Rails. é uma Pena que o Github não tenha um gerenciamento de bugs (Bug Tracker) integrado a ele, e a opção que foi adotada inclusive pelo Rails o Lighthouse, eu particularmente não me agradei, sinceramente eu preferia o Trac ou o Próprio Redmine que também é Feito em Rails.
o Bazaar tem o Launchpad, que é totalmente gratuíto, destinado a projetos Opensource, possui um ótimo Issue Tracker integrado e mais um monte de coisas legais como os Blueprints e sistema para auxílio a internacionalização, é uma Excelente ferramenta, que na minha opinião melhor de todas aqui citadas, porém eu mesmo acho ele um pouco lento às vezes se comparado com o Github. Mas se formos levar em conta que o Github tem (no momento da escrita deste artigo) um limite de 100Mb por conta de usuário para projetos Pessoais/Públicos (Provavelmente isso deve poder ser negociado com o Pessoal do Github) Launchpad continua melhor, pois não possui limite, entretanto eu realmente gostaria que o pessoal da Canonical criasse a possibilidade de ter Contas Premium para projetos privados no Launchpad (que eu nunca vi mas pode até ser que exista, pois o launchpad em si não é OpenSource, embora partes dele sejam).
Final da história
Meu escolhido foi o Bazaar. Se eu já utilizasse apenas Linux e não tivesse mais desenvolvedores para ter que botar na cabeça todos os comandos, talvez eu tivesse optado pelo Git, embora hoje em dia depois de utilizar os dois no dia a dia acho o Bazaar realmente melhor que o Git, além do mais o Bazaar vem evoluindo rapidamente inclusive no quesito da performance que seria o seu ponto mais fraco. Em todo caso se as coisas um dia ficarem realmente lentas eu sempre terei a opção de migrar para o Git.
Hoje em dia eu particularmente utilizo o Git com bastante frequência assim como o Carlos, e assim provavelmente vamos continuar fazendo, quando se tratar de algo relacionado ao Ruby On Rails, em contrapartida nossos projetos da Empresa e pessoais, além de outros tipos de controle de versão de documentos e arquivos binários eu vou continuar utilizando o Bazaar.
Em breve estarei postando um how to, bastante sem criatividade pois pretendo refazer o artigo do Akita utilizando o Bazaar para exemplificar o uso, semelhanças e diferenças, além de mostrar que é possível trabalhar com o Bazaar em um modelo bastante aproximado, senão idêntico ao Git.
Todos os testes foram realizados em aproximadamente umas 3 semanas, não foram apenas testes de 5 minutos em cada opção de ferramenta.
Tudo que eu escrevi aqui está diretamente relacionado ao meu cenário de trabalho e experiências, provavelmente para outros cenários e pontos de vista uma das outras ferramentas citadas ou mesmo não citadas se encaixam melhor.
* Veja mais sobre controle de versão distribuído neste link (Em Inglês) e não deixe de assistir o vídeo.
** Os pacotes em Python são chamados de Eggs, seriam equivalentes aos Gems do Ruby ou mesmo aos pacotes Deb ou RPM do linux.
*** O Ambiente Windows não é preparado para desenvolvedores
**** Conversa sem sentido onde dois ou mais grupos que não tem o que fazer, discutem incansávelmente para provar que sua ferramenta é melhor que a do outro
***** Grande Ironia, Um dos maiores causadores de Blames que eu já vi foram comparativos entre Java e Python, e os Javeiros Inteligentes passam a usar uma ferramenta em Python… já os outros…. devem estar chorando.
Coisas Legais / Cool Things!
