Système de build

Bonjour à tous.

J'ai récemment commencé un gros projet en Pony et, la taille du projet augmentant de plus en plus, je suis face à un problème concernant le choix d'un système de build.
Je vous explique rapidement le fonctionnement du compilateur Pony. Un programme Pony est divisé en packages, un par dossier. L'endroit d'où est lancé le compilateur détermine le package principal, qui sera le point d'entrée du programme. Par exemple, la commande ponyc --output=../build/ lancée dans le dossier foo/bar génèrera l'exécutable foo/build/bar.
Mon problème est le suivant : mon projet est composé de plusieurs modules, chacun générant un exécutable. J'ai donc cherché à automatiser le processus. Pour l'instant, j'ai écrit un script bash (très moche, attention les yeux) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#!/bin/bash

root_dir=$PWD

make_foo=false
make_bar=false

if [ $# -eq 0 ]; then
        make_foo=true
        make_bar=true
else
        for arg in "$@"; do
                if [ $arg = "foo" ]; then
                        make_foo=true
                elif [ $arg = "bar" ]; then
                        make_bar=true
                fi
        done
fi

if [ ! -d "build" ]; then
        mkdir "build"
fi

if [ $make_foo = true ]; then
        cd "src/foo"
        ponyc --path=$root_dir/src --output=$root_dir/build
        cd $root_dir
fi
if [ $make_bar = true ]; then
        cd "src/bar"
        ponyc --path=$root_dir/src --output=$root_dir/build
        cd $root_dir
fi

Évidemment, ce script est très peu pratique à maintenir au fur et à mesure de l'évolution du projet, n'est pas portable, etc. N'étant pas expert dans ce domaine, je me tourne vers vous afin d'avoir des avis sur le système à utiliser. Les principales caractéristiques que je recherche sont :

• Indépendant du langage traité ;
• Syntaxe concise ;
• Possibilité de spécifier les modules à compiler en fonction des arguments fournis ;
• Portabilité.

D'avance, je vous remercie.

Un système de build fonctionnant pour tout langage je n'en connais qu'un: make. Pourquoi ne pas avoir choisi d'utiliser des Makefiles ?

Ça me semble répondre à tous tes critères sauf la portabilité, mais il doit y avoir moyen de dr débrouiller (je dis ça parce que je n'ai jamais fait ça sur Windows, mais ça marche très bien sous Linux et BSD et OS X).

Tu peux aussi utiliser cmake (en langage perso) / premake (en lua) / scons (en python) pour générer des makefile et des projets pour les EDI, peu importe le système sur lequel tu l'utilises.

Tu ne trouves pas ton bonheur ici ?

Merci pour vos réponses.

J'avais écarté les Makefiles car ils me semblaient incompatibles avec la structure du système de build de Pony. Après avoir creusé un peu, ça s'avère possible de les utiliser. En temps normal, je n'aime pas utiliser un système aussi bas niveau que make, mais je me rabattrai probablement dessus si je ne trouve pas mieux.

Le problème des deux premiers, c'est que je n'arrive pas à mettre la main sur la documentation couvrant la gestion de langages non supportés nativement. J'ai trouvé celle pour scons, je regarderai plus en détail.

J'avais déjà fait un tour sur cette page, mais j'ai eu du mal à faire le tri.

Bref, je pense avoir recueilli assez d'informations pour passer le sujet en résolu. Merci à vous.

make est peut-être bas niveau au sens où tu dois concevoir ton makefile toi-même, mais c'est toujours la même chose et je copie mes anciens Makefiles. C'est super flexible comme système, j'ai par exemple un Makefile qui roote tout seul ou active le transfert de fichiers de mon téléphone, j'en avais marre de tout faire à la main

Désolé de remonter le sujet, mais au hasard de Twitter je suis tombé sur Buck. Je n'ai pas testé (pour le type de projets que je fais, Gradle + Gulp fonctionnent bien) mais peut-être que ça peut t'intéresser ?

EDIT : La doc est un peu bizarroïde, ils y parlent beaucoup de mobiles (les 2 templates pour se mettre le pied à l'étrier sont iOS et Android), pourtant on peut l'utiliser pour un projet C++ / Python notamment. Je pense que Buck prend tout son sens justement dans un environnement multi-langage.