Pacote Debian/Ubuntu para o LogicParser

Seguindo esse excelente tutorial, consegui fazer um pacote pra instalar o LogicParser em distribuições derivadas do Debian. Antes de explicar como foi, tenho de dizer que fazer o primeiro pacote .deb é totalmente lol. Não me perguntem por quê, é algo totalmente emocional. 😉

LogicParser Debian Package

A coisa foi muito facilitada por eu já estar usando autotools no projeto, como expliquei num post anterior, e pelo fato da aplicação ser bem simples. Tudo que tive de fazer foi usar um par de utilitários debian: dh_make e debuild.

Para instalar o que é preciso (além do build-essential):

apt-get install dpkg-dev debhelper devscripts fakeroot linda dh-make

Agora é necessário criar um diretório debian dentro do diretório da aplicação. Normalmente eu trabalho com a versão do SVN num diretório chamado logicparser, mas para fazer o pacote .deb é necessário usar um esquema de nome que inclua a versão da aplicação separada por um hífen, então fiz uma cópia chamada logicparser-0.7.2.

Uma vez dentro de logicparser-0.7.2 executei o comando

dh_make --native --single --email meuemail@mail.com

Isso cria um diretório debian com vários arquivos template, a maioria desnessária para uma aplicação simples, então foram apagados:

rm debian/*.ex debian/*.EX debian/README*

O parâmetro –native significa pacote debian nativo, que foi a forma que escolhi pra fazê-los; –single diz que a aplicação consiste de apenas um executável.

O único arquivo que precisou ser alterado foi o debian/control, para acrescentar uma descrição, a versão e arquitetura alvo:

Source: logicparser
Section: universe/misc
Priority: optional
Maintainer: Marcelo Lira dos Santos <meuemail@email.com>
Build-Depends: debhelper (>= 5), autotools-dev
Standards-Version: 0.7.2

Package: logicparser
Architecture: i386
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Simple parser and calculator for logic propositional expressions. Parser of logical propositions. It generates a parsed tree, a graph in DOT format, and renders it in PNG if GraphViz is available. It also calculates the expression based in values given by the user.

Em seguida a compilação via o script debian/rules dentro de um ambiente fakeroot:

fakeroot debian/rules binary

E finalmente as criação do pacote .deb (ele deve aparecer fora do diretório logicparser-0.7.2):

debuild -us -uc

Esses dois parâmetros são para desabilitar a assinatura de pacotes, o que me faz lembrar que já tá na hora de eu arrumar uma chave PGP…

Foi mais fácil do que pensei, embora saiba que a coisa pode ficar bem mais elaborada. Depois vou ver como automatizar ainda mais o processo a ponto de dar um make deb ou algo assim.

Downloads:

Anúncios

O primeiro Autotools é inesquecível!

Depois de muitas e muitas baixadas de tar.gzês de terceiros, pra descompactar e dar ./configure ; make ; make install, usar autotools em meu próprio projeto dá uma sensação muito boa! Sou praticamente gente grande! =P

Mas tenho de admitir começar foi complicado, são muitas as informações, felizmente pude contar com este excelente tutorial:

Ele faz um progresso gradual, com boas explicações e exercícios. Uma pena que o exemplo com GTK+ esteja totalmente deprecated. Para compensar esse problema e tocar meu projeto, usei um ardil descarado: criei um projeto GTK+ chamado gtk-foo no Anjuta (apt-get install anjuta autogen), sem suporte a internacionalização, pra não complicar as coisas.

Copiei os arquivos autogen.sh e configure.in, Makefile.am, aclocal.m4 e src/Makefile.am de gtk-foo para logicparser. Além disso foi necessário criar os conhecidos arquivos README, NEWS, ChangeLog, etc, conforme manda a tradição. Também foi necessário copiar alguns scripts de /usr/share/automake-1.9 para o diretório do projeto: depcomp, install-sh e missing.

Depois disso alguns ajustes precisaram ser feitos, como em lp_app.h, por exemplo, que guardava a indicação de onde encontrar o arquivo lp_gui.glade, já que o make install deveria colocar o arquivo glade em /usr/local/share/logicparser/glade.

Como ficou o trecho do header lp_app.h:

// For testing propose use the local (not installed) glade file
//#define GLADE_FILE "lp_gui.glade"
#define GLADE_FILE PACKAGE_GLADE_DIR"/lp_gui.glade"

O macro PACKAGE_GLADE_DIR é setado pelo compilador e foi definido em src/Makefile.am:

gladedir = $(datadir)/logicparser/glade
glade_DATA = lp_gui.glade

INCLUDES = \

-DPACKAGE_LOCALE_DIR=\""$(prefix)/$(DATADIRNAME)/locale"\" \
-DPACKAGE_SRC_DIR=\""$(srcdir)"\" \
-DPACKAGE_DATA_DIR=\""$(datadir)"\" \
-DPACKAGE_GLADE_DIR=\""$(gladedir)"\" \
$(PACKAGE_CFLAGS)

AM_CFLAGS =\

-Wall\
-g

bin_PROGRAMS = logicparser

logicparser_SOURCES = \

logicparser.c \
lp_app.c \
lp_graph.c \
lp_test.c \
logicparser.h \
lp_app.h \
lp_graph.h \
main.c

logicparser_LDFLAGS =

logicparser_LDADD = $(PACKAGE_LIBS)

EXTRA_DIST = $(glade_DATA)

O que mais gostei nesse início de uso do Autotools foi o make dist, que gera um logicparser-x.y.z.tar.gz. E por falar nele, podem baixar a última versão (0.4.2) na seção de Downloads: http://code.google.com/p/logicparser/downloads/list

Resta aprender como incluir suporte à internacionalização (provavelmente com ajuda do Anjuta 🙂 e build para Win32. Mas agora chega, estou caindo de sono. Se interessou, veja o site do autotut mencionado acima.

Compilando LogicParser em Win32 com MinGW e MSYS

Minha primeira e emocionante compilação de algo que estava desenvolvendo no Linux no insalubre ambiente Win32. Primeiro o screenshot e depois a história:

LogicParser no Windows

O ambiente de build foi montado usando MinGW/MSYS/msysDTK e o GTK+/Win32 Development Environment. A primeira compilação deu errado, mas setei a variável de ambiente PKG_CONFIG_PATH para /c/temp/GTK/2.0/lib/pkgconfig e tudo correu muito bem, mais fácil do que esperava. Depois vou ver como compilar estático pra fazer um executável morbidamente obeso, mas muito conveniente.

A aba “Graph (Image)” não funciona pois não consegui instalar o GraphViz no computador do CIn pois não tenho privilégios de administrador. Pelo menos isso me ajudou a decidir usar o GraphViz via biblioteca em lugar de usar o g_spawn_sync da GLib para chamá-lo externamente. Além disso, pra esse negócio ficar mesmo cross-platform tenho de usar algumas funções utilitárias da GLib, como g_get_tmp_dir e coisas assim.

Referências úteis nessa empreitada:

LogicParser

Fiz o primeiro commit do LogicParser, um programinha que ‘parseia’ expressões lógicas do tipo “!(p1 -> ( p2 & p3))“, que comecei a fazer logo após quase ter desistido da cadeira de Lógica. No período seguinte o professor começou a pedir um projeto do tipo pra galera, embora eu nunca tenha mostrado pra ele. Originalmente tinha uma interface GTK+, mas resolvi fazer um refactor e também aprender coisas básicas sobre projetos de software livre, como, por exemplo, aqueles arquivos README, ChangeLog, etc.
Já fiz o primeiro release, contando com o parser e um exemplo que roda na linha de comando.
Os planos para o futuro são:

  • interface GTK+
  • build com o CMake
  • saída da árvore como PNG e SVG, com o GraphViz
  • internacionalização
  • atribuição de valores e avaliação de expressões (possivelmente 2.0)

Ainda estou definindo uma política de numeração de versões, por hora estabeleci objetivos que quero alcançar e atribuí uma versão para cada um. Fico em dúvida se mudanças menos visíveis ao usuário final, como passar a usar CMake, deveriam entrar como 0.x ou 0.x.y, ou seja, considerar como uma alteração menor.
Dois documentos me ajudaram:

Projeto LogicParser no Google Hosting: http://code.google.com/p/logicparser

Update: mudei de idéia sobre o CMake. Autotools ruleia.