Environnement de développement

    From The Document Foundation Wiki
    < Macros‎ | Python Guide‎ | fr

    Introduction |Table des matières| Ma première macro

    Environnement de développement

    Nous abordons ici dans un premier temps, comment éditer les macros Python dans LibreOffice ?

    Puis nous aborderons, comment assurer un suivit des modifications et comment travailler à plusieurs sur les macros ?

    Éditer ses macros Python

    Comment éditer ses macros Python dans LibreOffice ?

    Par défaut dans LibreOffice il n'est pas possible d'éditer des macros Python :

    Lancer le gestionnaire de macros python de LibreOffice
    Le gestionnaire LibreOffice des macros python


    Nous pouvons observer deux arbres contenant des macros Python dans la Fenêtre de dialogue Macros Python.

    Mes macros : Les macros de l'utilisateur

    Ces macros se trouvent à l'emplacement :

    • Pour linux:
    ~/.config/libreoffice/4/user/Scripts/python/
    
    Emplacement des macros python de l'utilisateur

    Macros LibreOffice : Les macros accessibles à tous les utilisateurs

    Ces macros se trouvent à l'emplacement :

    • Pour linux:
    /usr/lib/libreoffice/share/Scripts/python/
    
    Emplacement des macros python pour tous les utilisateurs

    L'éditeur de macros Python

    LibreOffice n’offre pas encore d’éditeur pour Python. Ces limitations sont dues au manque de développeurs.

    Si vous voulez des macros Python, vous devez donc utiliser un éditeur externe pour modifier vos macros affichées dans Mes macros ou dans Macros LibreOffice.

    Il existe une extension, que vous pouvez télécharger sur le site des extensions de libreoffice Téléchargement, qui vous permet d'intégrer un éditeur python externe.

    Installation d'un Environnement de Développement pour les macros Python

    Pour l'installer, lancez LibreOffice.

    Ouvrez le menu Outils/Gestionnaire des extentions... Ctrl+Alt+E.

    Lancement du gestionnaire de macros complémentaires


    Dans la boite de dialogue Gestionnaire des extensions, cliquez sur le bouton «Ajouter...» au bas de la fenêtre.

    Gestionaire des extensions


    Dans la fenêtre Ajouter des extensions, recherchez et sélectionnez le fichier apso_v?.?.?.oxt lien téléchargement que vous avez téléchargé précédemment. Puis cliquez sur le bouton «Ouvrir».

    Ajout de l'extension


    Une fenêtre Contrat de licence du logiciel d'extension apparait. Lisez et faite défiler le texte jusqu'a la fin avec la bare de défilement vertical, ou le bouton «Défiler vers le bas».

    Vous pouvez valider avec le bouton «Accepter» si vous êtes d'accord avec ce contrat pour utiliser l'extension.

    Licence de l'extension


    Normalement, comme le lien de téléchargement ne référence pas la dernière version de cette extension, vous devez cliquer sur le bouton «Vérifier les mises à jour...» au bas de la boite de dialogue Gestionnaire des extensions.

    Bouton Vérifier les mises à jour…


    Faite la mise à jour de l'extension en cliquant sur le bouton «Installer» de la fenêtre Mise à jour de l'extension.

    Mise à jour de l'extension


    Une fois l'extension mise à jour cliquez sur le bouton «OK».

    Fin de la mise à jour


    Après un redémarrage de libreoffice un menu Gérer les scripts python Alt+Maj+F11 a été installé dans le menu Outils/Macros.

    Configuration du lanceur de l'éditeur de macros Python

    Vous devez d'abord avoir un éditeur pour Python d'installé.

    Dans nos exemples :

    • Pour Linux:
     Kate
    
    • Pour Windows
     notepad++
    

    Dans la fenêtre Gestionnaire des extensions repérez la macro complémentaire ::APSO::. Cliquez sur le bouton «Options...».

    Bouton Options…

    Dans la boite de dialogue Options-apso-EditorKicker :

    1. Dans la section Editeur saisissez votre éditeur de macro Python.

    Exemples :

     pour Linux : kate
     pour Windows : C:\Program Files (x86)\Notepad++\notepad++.exe
    
    1. Dans la section Options saisissez les paramètres à passer à l'éditeur en ligne de commande avec les variables utiles à la bonne exécution.

    Exemples :

      pour linux : {FILENAME}
      pour windows : -y{COL} -x{ROW} {FILENAME}
    
    Configuration de l'extension APSO

    Faites attention à ne pas oublier deux particularités de Python :

    • respecter la casse (majuscules/minuscules) pour les noms de variables,
    • et mettre des parenthèses vides dans tout appel d’une méthode sans argument.


    La gestion de versions

    La gestion de versions (en anglais version control ou revision control) consiste à maintenir des versions d'un ou plusieurs fichiers de macro. Ce logiciel va vous permettre d'avoir une historisation de vos modifications dans vos macros. Il va aussi être possible de partager collectivement le travail de dévellopement des macros.

    Vous n'êtes pas obligé d'utiliser un logiciel de gestion de versions pour de petites macros (quelques dizaines de lignes), mais c'est vivement conseillé au dela d'une centaine de lignes.

    Par contre si vous partez sur un développement collaboratif c'est une obligation.

    La gestion des historisations et des versions avec Git

    Git est un logiciel de gestion de versions décentralisé créer par Linus Torvalds.

    On enttend par décentralisé la possibilité de versionner en local ses modifications/créations de macros Python, avec la possibilité de pousser ces modifications/créations sur une ressource centralisée pour un travail collaboratif.

    Nous allons donc voir comment gérer ses versions de macros ?

    Puis comment centraliser ses macros Python pour une gestion collaborative de leur développement ?

    Pour installer le logiciel git exécutez ce tutoriel. Pour une documentation complète, consultez la page de manuel Git).

    Pour installer l'analyseur graphique des différences Kdiff3 suivez ce lien puis «Download» sur le menu à votre gauche.

    Configuration de git

    Sous Linux

    fichier /home/user/.gitignore_global

    *.pyc
    __pycache__
    .directory

    fichier /home/user/.gitmessage.txt

    Titre de votre historisation
    
    Description de ce que vous avez changé ou ajouté
    
    # S'il s'agit d'une résolution de ticket d'incident décommenter la ligne suivante
    #[ticket: n°X]

    #Activation de la colaration des messages
    user@station:~$ git config --global color.ui auto
    #Utilisateur de git
    user@station:~$ git config --global user.name "Prénom NOM"
    #Adresse courriel de l'utilisateur
    user@station:~$ git config --global user.email "monadressemail@fai.fr"
    #Editeur pour git
    user@station:~$ git config --global user.editor kate
    #Analyseur graphique des différences
    user@station:~$ git config --global user.tool kdiff3
    #Fichiers à ignorer
    user@station:~$ git config --global user.excludesfile ~/.gitignore_global
    #Message par défaut des validations d'historisations git
    user@station:~$ git config --global user.template ~/.gitmessage.txt
    #Voir la configuration de git
    user@station:~$ git config --list
      color.ui=auto
      user.name=Prénom NOM
      user.email=monadressemail@fai.fr
      core.editor=kate
      merge.tool=kdiff3
      core.excludesfile=/home/user/.gitignore_global
      commit.template=/home/user/.gitmessage.txt

    La Gestion de versions des macros

    Nous allons voir ici comment mettre en place la gestion de versions de nos macros python sous LibreOffice ?

    Puis nous verrons les commandes de manipulation de base de la gestion de versions des macros.

    Comment initialiser la gestion de versions sous LibreOffice ?

    Pour initialiser un nouveau dépot de version, il suffit d'utiliser la commande init de git.

    git init : crée un nouveau dépôt de macros. Cela crée un nouveau sous-répertoire nommé .git qui contient tous les fichiers nécessaires au dépôt ;

    En ligne de commandes
    • Sous Linux

    #Pour les macros de l'utilisateur
    git init /home/utilisateur/.config/libreoffice/4/user/Scripts/python/
    #Pour les macros partagées avec tous les utilisateurs
    sudo git init /usr/lib/libreoffice/share/Scripts/python/

    Pour plus d'informations voir la documentation

    Git sous KDE avec Dolphin
    Dossier du dépot git

    Touche «F4» pour afficher ou masquer le terminal sous Dolphin.

    Initialisation du dépot git

    Comment historiser un fichier ou une modification à git ?

    Votre dépot local de git est composé de trois parties gérées par git.

    La première est votre espace de travail où se situe réellement vos fichiers et dossiers.

    La seconde est une liste des changements dans vos structures de fichiers et de répertoires de l'espace de travail, appelé l'index, qui prend en compte toutes vos modifications depuis le dernier stockage des changements.

    La dernière est le stockage des changements dans la base git locale origin/master appelé HEAD qui pointe vers la dernière historisation que vous avez faite.

    Schéma de fonctionnement de git en local
    Comment ajouter un fichier ou une modification à la liste des changements ?

    Comment voir les fichiers qui ont été modifiés ou créés entre l'espace de travail et le dépot git ?

    git status : affiche l'état des modifications et de l'index.

    • Sous Linux

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git status
      Sur la branche master
      Modifications qui ne seront pas validées :
       (utilisez "git add <fichier>..." pour mettre à jour ce qui sera validé)
       (utilisez "git checkout -- <fichier>..." pour annuler les modifications dans la copie de travail)
      
             modifié :         Versions.py
     
      Fichiers non suivis:
       (utilisez "git add <fichier>..." pour inclure dans ce qui sera validé)
      
             test.py
      
      aucune modification n'a été ajoutée à la validation (utilisez "git add" ou "git commit -a")

    Comment voir ce qui a été modifié dans les fichiers ?

    git diff : affiche les différences entre les fichiers de l'espace de travail et le dépot git.

    • Sous Linux

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git diff  
      diff --git a/Versions.py b/Versions.py
      index 1987450..a6e0c60 100644
      --- a/Versions.py
      +++ b/Versions.py
      @@ -1,10 +1,12 @@
       #!
       #coding: utf-8
       # python Macro
      +


    git add : ajoute des nouveaux éléments modifiés dans la liste des modifications à historiser (l'index).

    • Sous Linux

    #Pour les macros de l'utilisateur
    cd /home/utilisateur/.config/libreoffice/4/user/Scripts/python/
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git add *.py
    #Pour les macros partagées avec tous les utilisateurs
    cd  /usr/lib/libreoffice/share/Scripts/python/
    utilisateur@station:/usr/lib/libreoffice/share/Scripts/python$sudo git add *.py
    #Voir le résultat de la mise en indexation pour historisation
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git status
      Sur la branche master
      Modifications qui seront validées :
       (utilisez "git reset HEAD <fichier>..." pour désindexer)
      
             modifié :         Versions.py
             nouveau fichier : test.py

    Pour plus de détails voir la documentation


    • Git sous KDE avoc Dolphin
    Le dossier n'as pas de mise à jour
    Un fichier du dépot git que l'on peut supprimer
    Un fichier a été modifié et peut être mis dans la file d'attente des mises à jour avec Git add
    Comment revenir sur les modifications de vos fichiers et dossiers, et sur l'historisation de la liste des changements ?
    • Revenir sur un changement dans un fichier

    git checkout -- NomDuFichier

    • Revenir sur le positionnement dans la liste des changements

    git reset HEAD NomDuFichier

    Pour plus d'informations sur git reset


    Exemple de restauration d'un fichier supprimé

    • Sous Linux

    #Visualisation entre l'état des fichiers du répertoire des macros python et le dépôt git
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git status    
      Sur la branche master
      Modifications qui seront validées :
        (utilisez "git reset HEAD <fichier>..." pour désindexer)
      
             supprimé :        Versions.py
    #Suppression du dernier commit dans git
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git reset HEAD
    #Visualisation entre l'état des fichiers du répertoire des macros python et le dépôt git avec son index
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git status
      Sur la branche master
      Modifications qui ne seront pas validées :
       (utilisez "git add/rm <fichier>..." pour mettre à jour ce qui sera validé)
       (utilisez "git checkout -- <fichier>..." pour annuler les modifications dans la copie de travail)
      
             supprimé :        Versions.py
    
      aucune modification n'a été ajoutée à la validation (utilisez "git add" ou "git commit -a")
    #Restauration de tous les fichiers à la dernière version de travail sauvegardée dans git
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git checkout .

    ou

    #Restauration du fichier Version.py à la dernière version de travail sauvegardée dans git
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git checkout -- Versions.py

    Revenir sur l'ensemble des changement depuis la dernière historisation (commit).

    #Supprime les demandes d'historisation de l'index et restaure les fichiers à leur état initial (Attention supprime tout ce qui a été créer depuis la dernière historisation)
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git reset --hard origin/master

    Pour plus de détails voir la documentation

    Comment ajouter les modifications au dépot git local de LibreOffice ?

    git commit : intègre les modifications du répertoire de travail qui sont indexées pour historisation dans le dépot local de git.

    • En ligne de commandes
    #Sous Linux
    #Pour les macros de l'utilisateur
    cd /home/utilisateur/.config/libreoffice/4/user/Scripts/python/
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git commit -m 'Version initiale du projet'
    #Pour les macros partagées avec tous les utilisateurs
    cd  /usr/lib/libreoffice/share/Scripts/python/
    utilisateur@station:/usr/lib/libreoffice/share/Scripts/python$sudo git commit -m 'Version initiale du projet'
    
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git log
      commit 5081147b1770efeff75ee1b7ac6ff99af5a2e735
      Author: Franc SERRES <sefran007@gmail.com>
      Date:   Tue Feb 28 22:53:56 2017 +0100
      
         Version initiale du projet
         
         Signed-off-by: Franc SERRES <sefran007@gmail.com>
    


    Pour plus de détails voir la documentation


    • Git sous KDE avoc Dolphin
    La sommes des modifications du dossier peut-être ajouté au dépot avec Git Commit
    Fenêtre d'information sur le commit
    Renseignement des informations de commit
    Version de commit validé par un tier
    Comment ajouter une version de développement au dépôt git local de LibreOffice ?

    Quel est le commit où nous voulons poser une étiquette ?

    • Sous Linux

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git log
      commit '''14e26fbbbd'''123456789abcdeffedcba987654321
      Author: Franc SERRES <sefran007@gmail.com>
      Date:   Fri Mar 3 10:23:35 2017 +0100
      
         Initialisation du dépôt de macros python

    Ou pour une vue synthétique :

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$ git log --pretty=oneline
      14e26fbbbd49e67a5fd1ba1390482ee4df142f49 Initialisation du dépot de macros python


    Mise en place de l'étiquette avec un commentaire

    • Sous Linux

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git tag -a V0.0.0 14e26fbbbd -m 'Mes macros de départ'
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git tag
      V0.0.0

    Visualiser le contenu de l'étiquette

    • Sous Linux

    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$ git show V0.0.0
      tag V0.0.0
      Tagger: Franc SERRES <sefran007@gmail.com>
      Date:   Fri Mar 3 10:57:28 2017 +0100
      
      Mes macros de départ
      
      commit 14e26fbbbd49e67a5fd1ba1390482ee4df142f49
      Author: Franc SERRES <sefran007@gmail.com>
      Date:   Fri Mar 3 10:23:35 2017 +0100
      
         Initialisation du dépôt de macros python
      
      diff --git a/Versions.py b/Versions.py
      new file mode 100644
      index 0000000..5c60237
      --- /dev/null
      +++ b/Versions.py
      @@ -0,0 +1,49 @@
      +#!
      +#coding: utf-8
      +# python Marco
      +import uno
      +from com.sun.star.awt.MessageBoxType import MESSAGEBOX
      +from com.sun.star.beans import PropertyValue
      +import platform
      +def omsgbox(oMessage='',oBtnType=1,oTitle='Title'):
      +       """shows message."""
      +       desktop = XSCRIPTCONTEXT.getDesktop()
      +       frame = desktop.getCurrentFrame()
      +       window = frame.getContainerWindow()
      +       toolkit = window.getToolkit()
      +       msgbox = toolkit.createMessageBox(window, MESSAGEBOX, oBtnType, oTitle, oMessage)
      +       return msgbox.execute()

    Pour plus de détail voir la documentation

    Le travail collaboratif

    Comment mettre en place un dépot git distant pour nos macros Python ?

    Il existe quatre façons d'accéder à un dépot distant pour Git.

    1. Un partage réseau local.
    2. Un serveur web autentifiant.
    3. Un accès SSH.
    4. Le protocole Git.
    le dépôt sur partage réseau local
    • Sous Linux

    #Création du dépôt git local centralisé
    sudo mkdir /srv/git
    #Création du dépôt de macros python LibreOffice
    sudo mkdir /srv/git/macros.git
    #Initialisation git du dépôt de macros python LibreOffice
    sudo git --bare init /srv/git/macros.git
    #Droits d'écriture et d'exécution pour tous les utilisateurs
    sudo chmod -R o+wx /srv/git/macros.git

    si vous n'avez pas déjà initialisez le dépôt local :

    • Sous Linux

    #Se positionner dans le répertoire personnel des macros LibreOffice
    cd /home/utilisateur/.config/libreoffice/4/user/Scripts/python
    #Initialiser git dans le répertoire personnel des macros
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git init
    #Ajouter tous les fichiers existants à l'index git
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git add .
    #Sauvegarder dans la base git tous les fichiers initiaux
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git commit -m 'Initialisation du dépot de macros python'

    se connecter au dépôt distant :

    • Sous Linux

    #Ajout du dépôt distant local à la base locale git des macros de l'utilisateur
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git remote add origin file:///srv/git/macros.git
    #Vérification de l'état du lien entre les dépôts
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$ git remote -v
      origin  file:///srv/git/macros.git (fetch)
      origin  file:///srv/git/macros.git (push)

    Initialisation avec le contenu de votre dépôt local

    • Sous Linux

    #Mise à jour du dépôt git distant avec les modifications git du dépôt local
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git push origin master
      Décompte des objets: 41, fait.
      Delta compression using up to 4 threads.
      Compression des objets: 100% (41/41), fait.
      Écriture des objets: 100% (41/41), 69.49 KiB | 0 bytes/s, fait.
      Total 41 (delta 7), reused 0 (delta 0)
      To file:///srv/git/macros.git
       * [new branch]      master -> master

    le dépôt accessible par ssh

    Création de l'utilisateur du dépôt

    • Sous Linux

    #Ajout de l'utilisateur git
    sudo adduser git
    #Connexion en tant qu'utilisateur git
    su git
    #Positionnement dans le répertoire maison (home) de l'utilisateur git
    cd
    #Création du répertoire des identifiants sécurisés ssh
    mkdir .ssh

    Ajout des utilisateurs pouvant accéder au dépôt avec leur clé ssh

    • Sous Linux

    #Ajout des identifiants publics d'autorisation d'accès pour le dépôt git
    cat /home/utilisateur/.ssh/id_rsa.pub >> /home/git/.ssh/authorized_keys
    cat /tmp/id_rsa.AutreUtilisateur.pub >> /home/git/.ssh/authorized_keys
    #sortir de la connexion avec le compte git (su git)
    exit

    donnez les droits à git sur les répertoires du dépôt distant

    • Sous Linux

    #Affectation du répertoire git et de ses fichiers avec les sous répertoires à l'utilisateur git et au groupe users 
    sudo chown -R git:users /srv/git
    #Vérification de l'affectation
    ls -ail /srv/git/macros.git
      total 40
      1183411 drwxr-xrwx  7 git users 4096 mars   3 10:22 .
      1195522 drwxr-xr-x  3 git users 4096 mars   3 10:17 ..
      1310846 drwxr-xrwx  2 git users 4096 mars   3 10:22 branches
      1187683 -rw-r--rwx  1 git users   66 mars   3 10:22 config
      1187681 -rw-r--rwx  1 git users   73 mars   3 10:22 description
      1187682 -rw-r--rwx  1 git users   23 mars   3 10:22 HEAD
      1310850 drwxr-xrwx  2 git users 4096 mars   3 10:22 hooks
      1310842 drwxr-xrwx  2 git users 4096 mars   3 10:22 info
      1310913 drwxr-xrwx 44 git users 4096 mars   3 10:23 objects
      1183412 drwxr-xrwx  4 git users 4096 mars   3 10:22 refs

    se connecter au dépôt distant :

    • Sous Linux

    #Ajout du dépôt distant git à la base locale git des macros python de l'utilisateur LibreOffice
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$git remote add ssh git@localhost:/srv/git/macros.git
    #Vérification de l'état du lien entre les dépôts
    utilisateur@station:~/.config/libreoffice/4/user/Scripts/python$ git remote -v
      origin  file:///srv/git/macros.git (fetch)
      origin  file:///srv/git/macros.git (push)
      ssh     git@localhost:/srv/git/macros.git (fetch)
      ssh     git@localhost:/srv/git/macros.git (push)

    Pour plus d'informations voir la documentation

    Gestion du dépôt distant

    • Git en ligne de commandes

    Se connecter à un dépot distant :

    Vérifier les connexions existantes déjà réalisées pour ce dépôt

    git remote -v : URLs stockées par Git.

    • Sous Linux

    utilisateur@poste:~/.config/libreoffice/4/user/Scripts/python$ git remote -v

    Se connecter au serveur distant

    git remote add <Serveur> : se connecter à un serveur git distant par défaut origin.

    • Sous Linux

    utilisateur@poste:~/.config/libreoffice/4/user/Scripts/python$ git remote add file:///srv/git/macros.git

    git remote add <nom> <Serveur> : se connecter à un serveur git distant avec un autre nom que origin.

    • Sous Linux

    utilisateur@poste:~/.config/libreoffice/4/user/Scripts/python$ git remote add ssh git@localhost:/srv/git/macros.git

    Voir les différences entre le dépôt distant et le local :

    git fetch : Met à jour la liste des différences entre le dépôt local et le dépôt distant.


    Mettre à jour le dépôt local avec le dépôt distant :

    git checkout : extrait le contenu dans le répertoire de travail.

    git push origin master : met à jour le serveur distant avec le dépôt local master.

    git pull : met à jour le dépôt local avec le serveur distant.

    git clone <Serveur> : clone un dépôt distant dans un dossier de macros (git init + git remote add + git fetch + git checkout).


    Pour plus d'informations voir la documentation


    • Git sous KDE avoc Dolphin
    Dossier du dépot git
    La sommes des modifications du dossier peut-être ajouté au dépot avec Git Commit

    Gestion des branches

    • Git en ligne de commandes

    git checkout -b Test : création d'une branche Test en local.

    git push origin Test : mise à jour de la branche Test sur le serveur distant.

    git branch Test : crée une nouvelle branche de dévellopement de macros sur le serveur.

    git branch -d Test : supprime la branche Test du serveur.

    git diff Test master : Changements de la fussion de branches.

    git checkout master : bascule sur la branche master.

    git merge Test master : fusionne la branche Test dans master.

    • Git sous KDE avoc Dolphin

    Pour plus d'informations voir la documentation

    Introduction | Ma première macro