Depois de um longo período apenas mantendo a estabilidade da versão atual, tirei ontem o dia para concluir os ajustes necessários para a versão 0.6 do Yadsel, com foco quase que exclusivo em projetos construídos com Django.

Ocorre que antes disso, o Yadsel trabalhava somente com versões de forma linear, ou seja: uma classe, uma versão.

Isso permaneceu até a versão 0.4, quando implementei o recurso de Extensible Versions (versões extensíveis) e Partial Versions (versões parciais). Essa versão inaugurou a idéia de poder ter várias classes em uma só versão. Melhorou na organização dos arquivos de versões e possibilitou trabalhar várias aplicações compartilhando uma mesma versão.

Mas ainda assim, outro recurso era necessário para o uso cotidiano no Django. No Django, as aplicações são independentes umas das outras, e ainda assim, podem haver eventuais dependências. Isso cria a necessidade de suporte a múltiplas versões em um mesmo projeto, ou seja: cada aplicação, uma versão. Para isso foi necessário implementar o Version Space.

Version Space

O Version Space é um recurso novo do Yadsel que torna possível que cada "espaço" no controle de versões possua sua própria versão, histórico e log. No caso do Django, o version space traduz-se pelo nome da aplicação, em outros aplicações, o desenvolvedor pode implementar como bem quiser.

Em outras palavras: eu posso manter uma aplicação de newsletter em diversos projetos com evolução de versões independentes do restante, incluindo toda a parafernália de DDL e DML que o Yadsel suporta: Tabelas, Domínios, Triggers, Procedures, Views, etc.

Yadsel no Admin

No embalo do Version Space veio o suporte ao Admin. É simples, ao instalar a aplicação 'yadsel.drivers.django_app' em seu INSTALLED_APPS, seu Admin passará a exibir duas seções para visualizar logs e históricos da evolução do banco.

Yadsel pelo manage.py

O Yadsel implementa um novo comando ao manage.py: yadseltool. A lógica de funcionamento é a mesma da yadseltool independente, porém seguindo a sintaxe de comandos baseados aplicações do manage.py:

$ python manage.py help yadseltool
Usage: manage.py yadseltool [options] [appname ...]

Executes Yadsel database version control for the given app name(s).

Options:
  --settings=SETTINGS   The Python path to a settings module, e.g.
                        "myproject.settings.main". If this isn't provided, the
                        DJANGO_SETTINGS_MODULE environment variable will be
                        used.
  --pythonpath=PYTHONPATH
                        A directory to add to the Python path, e.g.
                        "/home/djangoprojects/myproject".
  --traceback           Print traceback on exception
  --action=ACTION       Action of evolution; up=upgrade, down=downgrade
  --from=FROM
  --to=TO
  --mode=MODE           Mode of output; hidden=messages are hidden, steps=step
                        by step, interactive=confirms actions, output=only
                        prints to output
  --test=TEST           Set test mode
  --history=HISTORY     Write history of versions
  --silent=SILENT       Keeps exception messages
  --log=LOG             Write a log of changes
  --version             show program's version number and exit
  -h, --help            show this help message and exit

Exemplo de chamada do yadseltool

$ python manage.py yadseltool minha_aplicacao

Mas como afinal utilizar o Yadsel em meu projeto Django?

Bom, primeiro é necessário baixar a versão 0.6 do Yadsel em sua máquina

http://yadsel.googlecode.com/files/yadsel-0.6-with-django-support.tar.gz

Feito o download, instale o Yadsel numa versão 2.4 ou superior do Python

$ python setup.py install

Em seu projeto, acrescente a seguinte aplicação à setting INSTALLED_APPS do arquivo settings.py

'yadsel.drivers.django_app'

Rode o syndcb

$ python manage.py syncdb

Serão criadas as duas tabelas necessárias para o histórico e log do Yadsel. Entenda que 'histórico' trata-se do controle das versões, é ele que sabe se sua aplicação está na versão X ou Y. O 'log' trata-se de cada comando SQL que é gerado e executado, assim como suas respectivas eventuais mensagens de erro.

Crie a seguinte estrutura de pastas em uma de suas aplicações:

minha_aplicacao/
minha_aplicacao/yadsel_versions/
minha_aplicacao/yadsel_versions/__init__.py
minha_aplicacao/yadsel_versions/versao1.py
minha_aplicacao/yadsel_versions/versao2.py
minha_aplicacao/yadsel_versions/versaoN.py

o arquivo __init__.py deve conter ou importar as classes de versões, que podem ser estruturadas como bem quiser, seja em módulos ou em pacotes.

O conteúdo provável do arquivo __init__.py será este:

from versao1 import *

E o do arquivo versao1.py (ou qualquer outro que contenha classes de versões) será provavelmente este:

from yadsel.core import *

class Version1(Version):
    version_number = 1

    def up(self):
        pass

    def down(self):
        pass

ou como este exemplo:

from yadsel.core import *

class MinhaVersao1(Version):
    version_number = 1

    def up(self):
        CreateTable('minha_tabela_nova',
            id = Integer(primary=True)
            name = Varchar(50, required=True),
        ).append_to(self)

        AlterTable('states',
            Add('percent', Decimal(15, 5, default=0)),
        ).append_to(self)

        ExecuteSQL("""
            Create or Alter Procedure sp_teste...
        """).append_to(self)

    def down(self):
        ExecuteSQL("""
            Drop Procedure sp_teste
        """).append_to(self)

        AlterTable('states',
            DropColumn('percent'),
        ).append_to(self)

        DropTable('minha_tabela_nova').append_to(self)

A minha sugestão é que se use o Yadsel no Django somente para manter a evolução, não para criar tabelas em si. Isso porque o Django o já cria as tabelas muito bem. O que ele não faz é o resto :D