% !TEX root = BuildWithGBP.nw
\part{Plugins und Skripte}

\chapter{Java-Plugin}

<<build-gbp-java-plugin.sh>>=
#!/usr/bin/bash

# Copyright 2019-2025 Mechtilde and Michael Stehmann <mechtilde@debian.org>
# version 0.9.9

# java plugin for build-gbp.sh

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 31 Milk Street, #960789 Boston,
# MA 02196, USA.

<<Rules4Java>>
@

\section{Anpassungen für \texttt{Java}-Pakete}
\label{sec:JavaAdaption}

In der Datei \textit{debian/rules} (Kapitel~\ref{subsec:rules}, 
Seite~\pageref{subsec:rules}) werden für das Kompilieren mit \texttt{Java} 
folgende Zeilen hinzugefügt:

<<Rules4Java>>=
function Rules4Java {
    echo "export JAVA_TOOL_OPTIONS := -Dfile.encoding=UTF8" >>\
     ${GitPath}/debian/rules
    echo -e "export JAVA_HOME := /usr/lib/jvm/default-java\n" >>\
     ${GitPath}/debian/rules
}
<<build-gbp-java-plugin>>
@

Dies bedeutet, dass:
\begin{enumerate}
 \item{Immer das UTF-8 encoding genutzt wird}  
 \item{die Variable \textit{JAVA\_HOME} gesetzt ist.} 
\end{enumerate}
% Todo mit oder ohne export beschreiben

Vom Skript wird lediglich eine Minimalkonfiguration der Datei 
\textit{rules} bereitgestellt. Diese muss oft noch sinnvoll ergänzt werden. 
Für das Bauen der JAVA-Pakete werden häufig folgende Optionen benötigt.

\begin{verbatim}
    JMODS := /usr/lib/jvm/default-java/jmods
    JAVACMD="\$JAVA\_HOME/bin/java"
\end{verbatim}

Es kommt auch vor, dass \textit{JDK\_HOME} statt \textit{JAVA\_HOME} 
verwendet wird. 
%Es muss ausprobiert werden, ob noch jeweils ein "export" davor gesetzt 
%werden muss

% Der folgende Abschnitt muss noch dazu überprüft werden, was davon im 
%Maven-Plugin untergebracht werden muss.

Diese Ergänzungen werden für die mit dem \textit{maven}-Build-System 
erstellten Pakete vom \textit{Maven-Plugin} (Kapitel~\ref{chap:MavenPlugin}, 
Seite~\pageref{chap:MavenPlugin}) bereitgestellt.

In der Zeile mit \textit{dh \$@} können Optionen eingefügt werden.

\begin{description}
    \item[-{}-with javahelper]
    \item[-{}-buildsystem=maven]
    \item[-{}-buildsystem=ant]
    \item[-{}-buildsystem=gradle]
\end{description}

<<build-gbp-java-plugin>>=

whiptail --title "Java plugin found" \
--msgbox "build-gbp-java-plugin.sh was loaded." 15 60

echo "build-gbp-java-plugin.sh was loaded." >> ${log}
@

\chapter{Maven-Plugin}
\label{chap:MavenPlugin}

Das \texttt{Maven}-Plugin unterstützt das Bauen von \texttt{Java}-Paketen 
mit dem \texttt{Java}-Build-System \textit{maven} 
(Kapitel~\ref{subsec:JavaPaketMaven}, 
Seite~\pageref{subsec:JavaPaketMaven}).

\section{Kopf des Maven-Plugins}

Der Kopfteil des Plugins enthält Angaben zu den Urhebern und der Lizenz.

Außerdem ist vermerkt, welche \texttt{Debian}-Pakete für den Ablauf des 
Programmskriptes installiert sein müssen.

<<build-gbp-maven-plugin.sh>>=
#!/usr/bin/bash

# Copyright 2019-2025 Mechtilde and Michael Stehmann <mechtilde@debian.org>
# version 0.9.9

# maven plugin for build-gbp.sh

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 31 Milk Street, #960789 Boston,
# MA 02196, USA.

# Dependencies: maven-debian-helper licensecheck apt-file

<<Rules4MavenDH>>
@

\section{Mitteilung}

Das Plugin-Skript teilt mit, dass es geladen wurde. Damit ist der Code 
des Plugins Teil des (Haupt-)Programmskriptes.

<<MavenPlugin>>=
whiptail --title "maven plugin found" \
--msgbox "build-gbp-maven-plugin.sh was loaded." 15 60

echo "build-gbp-maven-plugin.sh was loaded." >> ${log}
# Next the function MakeMaven is executed by the main script.
# This is the end, my friend
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/MavenPluginLoaded.png} 
\caption{Maven Plugin geladen}
\end{figure}

\section{Bauen mit \textit{Maven}}
\label{sec:BuildWithMaven}

Diese Funktion wird nach dem Laden des Plugins beim Bauen einer neuen 
Revision von der Funktion \textit{BuildNewVersion} des 
(Haupt-)Programmskriptes aufgerufen 
(Kapitel~\ref{sec:RequestBuildWithMaven}, 
Seite~\pageref{sec:RequestBuildWithMaven}).

Die Ausführung von \textit{mh\_make} erfolgt in einer
\textit{Chroot}-Umgebung. Wenn die \textit{chroot} noch nicht existiert,
ist sie zunächst als \textit{/srv/maven-chroot} anzulegen wie in 
Kapitel~\ref{sec:MoreChrootSystems}
(Seite~\pageref{sec:MoreChrootSystems}) beschrieben.

<<MakeMaven>>=
function MakeMaven {
    # Called by BuildNewRevision

    cd ${GitPath}
    IdentifyMavenChrootPath

<<MakeMaven1>>
@ 

Nun wird die Funktion \textit{IdentifyMavenChrootPath} aufgerufen. Diese
Funktion prüft, ob die Variable \textit{ChrootPath} mit einem Wert
belegt ist.

<<IdentifyMavenChrootPath>>=
function IdentifyMavenChrootPath {
    # Called by MakeMaven and itself
    
    if [ -n "${ChrootPath}" ]
    then
        if ! whiptail --title "Maven chroot path " \
        --yesno "Is ${ChrootPath}\nthe right path to\n\
        maven chroot directory on the host?" \
        --yes-button "Yes" \
        --no-button "No" 15 60
<<IdentifyMavenChrootPath1>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/IdentifyMavenChrootPath.png} 
\caption{Pfad zur Maven-Chroot ermitteln}
\end{figure}

Wird der korrekte Pfad zur \textit{maven-chroot} angezeigt, geht es
weiter mit der Prüfung, ob die \textit{maven-chroot} auch an diesem Ort
eingerichtet ist.

<<IdentifyMavenChrootPath1>>=
        then
            OldCP=${ChrootPath}
            AskChrootPath
        fi
    else
        AskChrootPath
    fi

<<IdentifyMavenChrootPath2>>
@

<<AskChrootPath>>=
function AskChrootPath {
    # Called by IdentifyMavenChrootPath
    
    # This is the way from GitPath to /srv/maven-chroot
    ChrootPath=$(whiptail --title "Maven chroot path" \
    --inputbox "Please insert the path\nto the maven chroot directory\n\
    on the host:" \
    --nocancel 15 60 3>&2 2>&1 1>&3)
<<AskChrootPath1>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/MavenChrootPath.png} 
\caption{Pfad zur Maven-Chroot angeben}
\end{figure}

<<AskChrootPath1>>=

    if [ -n "${OldCP}" ]
    then
        ReplaceConfigLines "ChrootPath" ${ChrootPath}
    else
        echo "### Maven chroot path"
        echo "ChrootPath="${ChrootPath} >> ${ConfigPath}${OrigName}
    fi
    OldCP=""
}

<<AskWorkspacePath>>
@

Ist die \textit{maven-chroot} noch nicht eingerichtet, wird sie vom 
Programm-Skript im angegebenen Verzeichnis eingerichtet.

<<IdentifyMavenChrootPath2>>=
    # Create Maven-Chroot if not exists
    if ! [ -d ${ChrootPath} ]
    then
        echo "Please enter your SUDO password!"
        sudo mkdir --parents ${ChrootPath}
    fi
    
    if ! [ -d ${ChrootPath}/usr ]
    then
        echo "Please enter your SUDO password!"
        sudo /usr/sbin/debootstrap --arch amd64 sid \
        ${ChrootPath} http://ftp.de.debian.org/debian
        echo "The maven chroot has been created." >> ${log}
    fi

<<IdentifyMavenChrootPath3>>
@

Danach wird der Pfad für den Arbeitsbereich in der \textit{maven-chroot}
ermittelt.

<<IdentifyMavenChrootPath3>>=
    # The workspace is /home/user
    if [ -n "${Path2Workspace}" ]
    then
        if ! whiptail --title "Maven chroot path " \
        --yesno "Is ${Path2Workspace}\nthe workspace in the maven chroot?" \
        --yes-button "Yes" \
        --no-button "No" 15 60 # test
<<IdentifyMavenChrootPath4>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/WorkspaceMavenChroot.png} 
\caption{Arbeitsverzeichnis in der Maven-Chroot ermitteln}
\end{figure}

Wird die Frage nach dem Arbeitsbereich innerhalb der \textit{maven-chroot}
bejaht, wird das Arbeitsverzeichnis des Projektes in den Arbeitsbereich
der \textit{maven-chroot} kopiert (Seite~\pageref{par:MavenChrootWork}).

Sodann geht es mit der Arbeit innerhalb der \textit{maven-chroot} weiter.

<<IdentifyMavenChrootPath4>>=
        then
            OldP2W=${Path2Workspace}
            AskWorkspacePath
        fi
    else
        AskWorkspacePath
    fi
<<IdentifyMavenChrootPath5>>
@

<<AskWorkspacePath>>=
function AskWorkspacePath {
    # Called by IdentifyMavenChrootPath

    # This is the way to /home/user/
    Path2Workspace=$(whiptail --title "Maven chroot path" \
    --inputbox "Please insert the path\nto the workspace directory:" \
    --nocancel 15 60 3>&2 2>&1 1>&3)
<<AskWorkspacePath2>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/InsertMavenChrootWorkspace.png} 
\caption{Arbeitsverzeichnis in der Maven-Chroot angeben}
\end{figure}

<<AskWorkspacePath2>>=

    if [ -n "${OldP2W}" ]
    then
        ReplaceConfigLines "Path2Workspace" ${Path2Workspace}
    else
        echo "Path2Workspace="${Path2Workspace} >> ${ConfigPath}${OrigName}
    fi
    OldP2W=""
}

<<IdentifyMavenChrootPath>>
@

<<IdentifyMavenChrootPath5>>=
    # Replace / at the end
    Path2Workspace=$(echo ${Path2Workspace} | sed --expression="s/\/$//")
    MavenChrootPath=${ChrootPath}${Path2Workspace}
    if ! [ -d ${MavenChrootPath} ]
    then
        whiptail --title "Error!" \
        --msgbox "${MavenChrootPath} does not exist.\n\
        It will be created now." 15 60
<<IdentifyMavenChrootPath7>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/NonExistingMavenChroot.png} 
\caption{Maven-Chroot existiert nicht}
\end{figure}

Existiert die \textit{chroot} nicht, ist sie anzulegen wie in 
Kapitel~\ref{sec:MoreChrootSystems}, Seite~\pageref{sec:MoreChrootSystems} 
beschrieben.

<<IdentifyMavenChrootPath7>>=
        echo "Please enter your SUDO password!"
        sudo mkdir --parents ${MavenChrootPath}
        echo "The maven work space has been created." >> ${log}
    fi
}

<<MakeMaven>>
@

\paragraph*{}
% Anchor for Label
\label{par:MavenChrootWork}

Das Arbeitsverzeichnis des Projektes wird in den Arbeitsbereich
der \textit{maven-chroot} kopiert. Hierzu werden \textit{Root}-Rechte
benötigt.

<<MakeMaven1>>=
    # Copy workspace to maven chroot
    echo "To copy the sources into maven-chroot you need sudo rights"
    sudo cp --archive ${GitPath} ${MavenChrootPath}

    # Because mh_make has to run in the directory, where pom.xml is
    echo "pom.xml is here:"
    find . -name 'pom.xml' -print
    echo "Please switch to the Maven chroot in another terminal."
    echo
    echo "Use these commands:"
    echo
    echo "# sudo mount -o bind /proc "${ChrootPath}"/proc"
    echo "# sudo mount devpts /dev/pts -t devpts"
    echo
    echo "sudo LANG=C chroot "${ChrootPath}" /usr/bin/bash"
    echo "cd "${Path2Workspace}"/"${SourceName}
    echo "try: apt install maven-debian-helper"
    echo "apt update && apt upgrade"
    echo "mh_make --verbose "${SourceName}
    echo
    echo "Then follow the questions of mh_make"
    echo
    echo "You can leave the chroot with 'exit'."
    echo
    echo "After finishing press return to go on!"
    read a

    #--run-tests=true --javadoc=true --verbose
    #mh_make --package=${SourceName} --bin-package=${PackName} \
    #--run-tests=false --javadoc=false --verbose
    #if [ $? -ne 0 ]
    #then
    #    echo "mh_make failed!"
    #    exit
    #else    
    #    echo "mh_make has been executed for "${PackName} >> ${log}
    #fi
    
    cp --recursive --update ${MavenChrootPath}/${SourceName}/debian \
    ${GitPath}    

<<MakeMaven5>>
@

Beim Ablauf des Programmes \textit{mh\_make} sind folgende Fragen zu 
beantworten. Dieses Programm selber in auch ein Shell-Skript.

\begin{description}
    \item[Environment variable DEBLICENSE not set, using Apache-2.0 by default] 
    Es wird standardmäßig die Lizenz Apache-2.0 verwendet, wenn die
    Umgebungsvariable \textit{DEBLICENSE} nicht gesetzt ist.
    In der Variablen \textit{DEBLICENSE} wird die Lizenz für 
    die Dateien in \textit{debian/} hinterlegt.
    % ToDo: Beschreiben, wo diese Umgebungsvariablen definiert werden. 
    %(eventuell) vor der Ausführung abfragen.

    \item[Checking that apt-file is installed and has been configured\dots
    {{[}ok{]}}] Es wird geprüft, ob das Paket \textit{apt-file} installiert ist. 
    Dieses Paket ist nur als \emph{empfohlen} markiert.
    \item[Checking that licensecheck is installed\dots {{[}ok{]}}] 
    Prüfung, ob das Paket \textit{licensecheck} installiert ist. 
    Dieses Paket ist ebenfalls nur als \emph{empfohlen} markiert.
    \item[Solving dependencies for package <PaketName>]
    \item[Analysing pom.xml\dots] 
    \item[Resolving com.jcabi:jcabi:pom:1.21 of scope runtime\dots]
    % ToDo: Angaben zum speziellen Paket verallgemeinern
    \item[The parent POM cannot be found in the Maven repository for De\-bian.]
    % ToDo: Angaben zum speziellen Paket verallgemeinern
    Es ist der Regelfall, dass die Abhängigkeit für das Elternelement nicht
    gefunden wird. Daher wird die Frage bejaht, dass dies ignoriert werden 
    kann. Diese Information wird dann als als \textit{--no-parent} in die 
    Datei \textit{<PaketName>.poms} geschrieben.
    \item[Enter the upstream version for the package.] Hier wird die zu 
    bauende Versionsnummer des Upstream-codes abgefragt und in der Regel 
    mit \textit{Enter} bestätigt. Andernfalls wird die korrekte 
    Versionsnummer eingegeben.
    \item[Version of com.jcabi:jcabi-aspects is 0.22.6]
    % ToDo: Angaben zum speziellen Paket verallgemeinern
    Es wird nochmal die Versionsnummer angezeigt.
    \item[Choose how the version will be transformed:] Nun wird eine 
    Auswahl angezeigt, wie diese Versionsnummer umgewandelt werden soll.

    \begin{description}
        \item[0 - Replace all versions starting by 0. with 0.x] Es sollen
        alle Versionsbezeichnungen ersetzt werden.
        \item[(1) - Change the version to the symbolic 'debian' version] 
        Die Standardangabe wird mit eckigen Klammern (Hier sind es aus 
        satztechnischen Gründen runde Klammern) gekennzeichnet. Diese 
        kann mit \textit{Enter} bestätigt werden.
        \item[2 - Keep the version]
        \item[3 - Custom rule]
    \end{description}

    Andernfalls wird nun die gewünschte Ziffer eingegeben.
    \item[Inform mh\_make that dependencies of type jar which may match
    this library \\should be transformed into bundles automatically? 
    {[}Y/n{]}]
    % ToDo: Angaben zum speziellen Paket verallgemeinern
    Soll \textit{mh\_make} mitgeteilt 
    werden, dass die passenden Abhängigkeiten vom Typ \textit{jar} 
    in Bundles umgewandelt werden. Standardmäßig wird diese Frage bejaht.
    \item[\protect{\parbox[t]{15cm}{Resolving com.jcabi:jcabi-log:jar:0.17
     of scope runtime\dots 
    {$[$ check dependency with bundle type $]$}}}]
    % ToDo: Angaben zum speziellen Paket verallgemeinern
    \item[\protect{\parbox[t]{15cm}{In pom.xml: This dependency cannot
    be found in the Debian Maven 
    repository. Ignore this dependency?  com.jcabi:jcabi-log:jar:0.17
    {$[$ y/N $]$}}}] Diese Meldung kommt, wenn die benötigte Abhängigkeit
     nicht auf der Arbeitsmaschine installiert ist.
\begin{itemize}
    \item \textgreater dpkg --search /usr/share/maven-repo/com/jcabi/jcabi-log/*/* 
    dpkg failed to execute successfully
    \item \textgreater apt-file search /usr/share/maven-repo/com/jcabi/jcabi-log
    \footnotesize
    \begin{verbatim}
Found /usr/share/maven-repo/com/jcabi/jcabi-log/0.18.1/jcabi-log-0.18.1.pom
    in libjcabi-log-java
Found /usr/share/maven-repo/com/jcabi/jcabi-log/0.19.0/jcabi-log-0.19.0.pom
    in libjcabi-log-java
Found /usr/share/maven-repo/com/jcabi/jcabi-log/debian/jcabi-log-debian.pom
    in libjcabi-log-java
    \end{verbatim}
    \normalsize
\item \textgreater dpkg --search /usr/share/java/jcabi-log.jar 
dpkg failed to execute successfully
\item \textgreater apt-file search /usr/share/java/jcabi-log.jar 
Found libjcabi-log-java
[error] Package libjcabi-log-java does not contain Maven dependency 
com.jcabi:jcabi-log:jar:0.17 but there seem to be a match
If the package contains already Maven artifacts but the names don't match, 
try to enter a substitution rule of the form 
s/groupId/newGroupId/ s/artifactId/newArtifactId/ jar s/version/newVersion/ here:
> 
\end{itemize}
\end{description}

<<MakeMaven5>>=
    if [ -w debian/maven.rules ]
    then
        echo "#[groupId] [artifactId] [type] [version] [classifier] [scope]" \
        >> debian/maven.rules
    fi

    ShowMaven

<<MakeMaven6>>
@

\section{Maven-Dateien bearbeiten}
\label{sec:MavenDateienBearbeiten}

Pakete, die mit \textit{Maven (mvn)} gebaut werden, benötigen dazu 
weitere Dateien im Verzeichnis \textit{debian/}. 
Diese werden im Folgenden aufgelistet.

Die folgenden Daten wurden in der \textit{maven-chroot} erstellt:

\begin{itemize}
	\item <PackName.poms>
    \item maven.cleanIgnoreRules
    \item maven.properties
    \item maven.rules
    \item maven.ignoreRules
    \item maven.publishedRules
\end{itemize}

Nun können auch diese Dateien angezeigt und editiert werden.

<<ShowMaven>>=
function ShowMaven {
    # Called by DisplayDebianFiles MakeMaven

    mavenl=$(ls ${GitPath}/debian/ | grep 'maven')
    for element in ${mavenl[*]}
    do
        nano --linenumbers --mouse --softwrap debian/${element}
    done
    
    pomsl=$(ls ${GitPath}/debian/ | grep ${PackName})
    for element in ${pomsl[*]}
    do
        nano --linenumbers --mouse --softwrap debian/${element}
    done
}

<<AskChrootPath>>
@

<<MakeMaven6>>=

    # Patch for mh_make bug
    str4standardsversion="4.7.1"
    cd ${GitPath}/debian/
    less --LINE-NUMBERS control

    sed --in-place --expression=\
    "s/Standards-Version: 4.4.1/Standards-Version: ${str4standardsversion}/" \
    control
    # 'a' means append. The string after the 'a' will be appended 
    # to the sting before the 'a'.
    sed --in-place \
    --expression="/Standards-Version: ${str4standardsversion}/ \
    a Rules-Requires-Root: no" \
    control
    sed --in-place --expression=\
    "s/debhelper-compat (=12)/debhelper-compat ${str4versiondebhelpers}/"  \
    control

    cd ${GitPath}
    whiptail --title "Check debian/control" \
    --msgbox "Please check the control file another time!" 15 60
    less --LINE-NUMBERS ${GitPath}/debian/control
}

<<MavenPlugin>>
@

\subsection{maven.rules}

Diese Datei ist wie folgt aufgebaut:

<<maven-rules.header>>=
#[groupID] [artifactID] [type] [version] [classifier] [scope]
@

\subsection{maven.ignoreRules}

Diese Datei ist wie die Datei \textit{maven.rules} aufgebaut.

<<maven-ignoreRules.header>>=
#[groupID] [artifactID] [type] [version] [classifier] [scope]
@

Artefakte, die in der Datei \textit{maven.rules} aufgenommen werden, 
sind hier gegebenenfalls zu löschen

\subsection{maven.properties}
\label{subsec:MavenProperties}

Die Datei \textit{maven.properties} kann verwendet werden, um Werte von 
Variablen innerhalb der \textit{pom.xml}-Dateien zu überschreiben. Der
häufigste Anwendungsfall ist die Deaktivierung oder Aktivierung der Tests 
mit \textit{maven.test.skip=true}

Weitere Optionen sind die Änderung der Quell- (\textit{maven.compiler.source=8}) 
bzw. Zielebene (\textit{maven.compiler.target=8}). Dabei bezieht sich der 
Wert (hier: \textit{8}) auf die java-Mindestversion. Dieser Eintrag wird 
besonders dann benötigt, wenn beim Kompilieren eine Meldung wie die 
folgende ausgegeben wird: \textit{use -source 8 or higher to enable \dots}.

Außerdem kann hier die verwendete Dateikodierung 
(\textit{project.build.sourceEncoding\-=UTF-8}) eingestellt werden. 

<<maven.properties>>=
# Include here properties to pass to Maven during the build.
# For example:
# maven.test.skip=true
# project.build.sourceEncoding=UTF-8
# maven.compiler.source=8
# maven.compiler.target=8
# To skip test - missing dependencies
maven.test.skip=true
@

Häufig werden die Tests deaktiviert, um nicht zusätzliche Abhängigkeiten
paketieren zu müssen. In diesen Fällen sind diese Abhängigkeiten auch in
der Datei \textit{pom.xml} mit einem Kommentarzeichen zu versehen oder zu
entfernen.

Solche Änderungen am Upstream-Code können mit dem Programmskript
vorgenommen werden (Kapitel~\ref{chap:Aenderungen_am_Upstream_Code_vornehmen},
Seite~\pageref{chap:Aenderungen_am_Upstream_Code_vornehmen}).

\subsection{Paketname.poms}

In der Datei \textit{<Paketname>.poms} werden die Optionen zu den jeweiligen 
\textit{pom.xml}-Dateien hinterlegt. 

Die Datei enthält dann 2 Spalten. In der ersten Spalte steht die pom.xml 
mit dem dazugehörigen Pfad und in der zweiten Spalte die dazugehörigen 
Optionen, wie z.B. 

\begin{verbatim}
# List of POM files for the package
# Format of this file is:
# <path to pom file> [option]*
# where option can be:
#   --ignore: ignore this POM and its artifact if any
#   --ignore-pom: don't install the POM. To use on POM files that are 
#     created temporarily for certain artifacts such as Javadoc jars. 
#     [mh_install, mh_installpoms]
#   --no-parent: remove the <parent> tag from the POM
#   --package=<package>: an alternative package to use when installing 
#     this POM and its artifact
#   --has-package-version: to indicate that the original version of
#     the POM is the same as the upstream part of the version for the
#     package.
#   --keep-elements=<elem1,elem2>: a list of XML elements to keep in the 
#     POM during a clean operation with mh_cleanpom or mh_installpom
#   --artifact=<path>: path to the build artifact associated with this 
#     POM, it will be installed when using the command mh_install.
#     [mh_install]
#   --java-lib: install the jar into /usr/share/java to comply with
#      Debian packaging guidelines
#   --usj-name=<name>: name to use when installing the library in
#      /usr/share/java
#   --usj-version=<version>: version to use when installing the library
#     in /usr/share/java
#   --no-usj-versionless: don't install the versionless link in
#     /usr/share/java
#   --dest-jar=<path>: the destination for the real jar.
#     It will be installed with mh_install. [mh_install]
#   --classifier=<classifier>: Optional, the classifier for the jar. 
#     Empty by default.
#   --site-xml=<location>: Optional, the location for site.xml if it 
#     needsto be installed.
#     Empty by default. [mh_install]
#
pom.xml --no-parent --has-package-version
\end{verbatim}

Dies bedeutet, dass das <parent>-Tag beim Bauen aus der POM entfernt 
wird. Die Option \textit{--has-package-version} gibt an, dass die 
Originalversion der POM dieselbe sei, wie der Upstream-Teil der 
Paketversion.

\subsection{README.source}
\label{subsec:MavenReadmeSource}

\begin{verbatim}
    
Information about jcabi-aspects
------------------------------

This package was debianized using the mh_make command
from the maven-debian-helper package.

The build system uses Maven but prevents it from downloading
anything from the Internet, making the build compliant with
the Debian policy.
\end{verbatim}

\section{\textit{debian/rules} - Ergänzungen für \texttt{Java}-Pakete mit 
\textit{Maven}}
\label{sec:Rules4MavenDH}

In der Funktion \textit{Rules4MavenDH} wird die Datei \textit{debian/rules} 
um die Angabe des Build-Systems ergänzt. 

<<Rules4MavenDH>>=
function Rules4MavenDH {
    # Called by DebianRulesTemplates

    sed --in-place \
    --expression="s/dh \$@/dh \$@ --buildsystem=maven/" \
    ${GitPath}/debian/rules

}
<<ShowMaven>>
@

\chapter{Web-Extension-Plugin}
\label{chap:WebextPlugin}

Das nachstehend dargestellte Plugin erfüllt die besonderen Anforderungen 
beim Bauen von \texttt{Mozilla}-Erweiterungen als \texttt{Debian}-Pakete 
(Kapitel~\ref{chap:WebextBauen}, Seite~\pageref{chap:WebextBauen}).

\section{Kopf des Webext-Plugins}
Der Kopfteil des Plugins enthält Angaben zu den Urhebern und der Lizenz.

Außerdem ist vermerkt, welche \texttt{Debian}-Pakete für den Ablauf des 
Programmskriptes installiert sein müssen.

<<build-gbp-webext-plugin.sh>>=
#!/usr/bin/bash

# Copyright 2020-2025 Mechtilde and Michael Stehmann <mechtilde@debian.org>
# version 0.9.9

# webext plugin for build-gbp.sh

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 31 Milk Street, #960789 Boston,
# MA 02196, USA.

<<IdentifyWebextId>>
@

\section{Erstellen der \textit{webext*.*}-Dateien in \textit{debian/}}

\subsection{Ermittlung des Namens der \textit{*.xpi}-Datei}

Die zu paketierende Erweiterung muss unter dem Namen der sich aus der Bezeichnung (id) in 
der Datei \textit{manifest.json} und der Endung \textit{.xpi} zusammensetzt, 
abgelegt werden.

Die Bezeichnung wird daher wie folgt ermittelt. 

<<IdentifyWebextId>>=
function IdentifyWebextId {
    # Called by WebextRulesDH WebextInstall

    if [ -z ${webextID} ] && [ -f ${GitPath}/manifest.json ]
    then
        webextID=$(grep '"id":' ${GitPath}/manifest.json)
        webextID=$(echo ${webextID} | sed --expression='s/^\"id\": \"//')
        webextID=$(echo ${webextID} | sed --expression='s/\",\s*//')

        echo -e "Notice from Webext-Plugin: WebextID = "${webextID} >> ${log}
    fi

    if [ -z ${webextID} ]
    then
        webextID="PLEASE_REPLACE_WITH_ID"
        whiptail --title "ID not found" \
        --msgbox "Didn't find ID or manifest.json in ${GitPath}" 15 60
    fi
}

<<webext-rules>>
@

\subsection{\textit{debian/rules} - Ergänzungen für \texttt{Mozilla}-AddOns}
\label{subsec:webextrules}

Bei der \textit{debian/rules}-Datei für die Webextension ist es sinnvoll, 
die zu installierenden Verzeichnisse bzw. Dateien dort aufzuführen und 
einer Variablen zuzuweisen.Dies erfolgt nach dem Muster 
\textit{<Package>\_FILES = <List of files to include>}

Die Liste \textit{<Package>\_FILES} wird vom Plugin-Skript automatisch 
erstellt. Sie ist auf Vollständigkeit und Richtigkeit zu überrpüfen. Die 
auszuschließenden Dateien sind manuell einzupflegen.

Da die Anlage der Datei \textit{debian/rules} einmalig erfolgt, sind beim 
Paketieren neuer Versionen die beiden Listen sorgfältig zu prüfen und 
gegebenenfalls zu anzupassen. 

<<webext-rules>>=
function WebextRules {
    # Called by DebianRulesTemplate

    # These strings will be added to str4rules

    Package=$(echo ${SourceName} | tr "a-z" "A-Z")
    echo -e ${Package}"_FILES =  \\" >> ${GitPath}/debian/rules

    PackageL=$(ls ${GitPath})
    PackageA=(${PackageL})

    for element in ${PackageA[*]}
    do
        if [ "${element}" != "debian" ]
        then
            echo -e ${element}" \\" >> ${GitPath}/debian/rules
        fi
    done
    echo "\$(NULL)" >> ${GitPath}/debian/rules

<<webext-rules5>>
@

<<webext-rules5>>=
    echo -e "\n Uncomment the following lines \n"
    echo "if there are files to exclude and add them."
    echo -e "\n# "${Package}"_FILES_EXCLUDE =  \\" \
    >> ${GitPath}/debian/rules
    echo -e "# \$(NULL)\n" >> ${GitPath}/debian/rules
}

<<webext-rules-dh>>
@

Die folgenden Zeilen werden vom Programmskript der Variablen 
\textit{str4rulesdh} hinzugefügt.

<<webext-rules-dh>>=
function WebextRulesDH {
    # Called by DebianRulesTemplate

    IdentifyWebextId

    DHCleanStr="override_dh_clean:\n\tdh_clean\n\trm -rf debian/build\n"

    DHAutoBuildIndepStr1="override_dh_auto_build-indep:"
    DHAutoBuildIndepStr2="\tmkdir \$(CURDIR)/debian/build && \\"
    Str3B="\tzip --recurse-paths "
    DHAutoBuildIndepStr3=${Str3B}"\$(CURDIR)/debian/build/"${webextID}".xpi \\"
    DHAutoBuildIndepStr4="\t    \$(${Package}_FILES) \\"
    DHAutoBuildIndepStr5="# \t    --exclude \$(${Package}_FILES_EXCLUDE)"
    DHAutoBuildIndepStr6="\tdh_auto_build\n"

    echo -e ${DHCleanStr} >> ${GitPath}/debian/rules
    echo -e ${DHAutoBuildIndepStr1} >> ${GitPath}/debian/rules
    echo -e ${DHAutoBuildIndepStr2} >> ${GitPath}/debian/rules
    echo -e ${DHAutoBuildIndepStr3} >> ${GitPath}/debian/rules
    echo -e "${DHAutoBuildIndepStr4}" >> ${GitPath}/debian/rules
    echo -e "${DHAutoBuildIndepStr5}" >> ${GitPath}/debian/rules
    echo -e ${DHAutoBuildIndepStr6} >> ${GitPath}/debian/rules
}

<<WebextControl>>
@

\subsection{\textit{debian/control} - Ergänzungen für \texttt{Mozilla}-AddOns}
\label{subsec:WebextControl}

<<WebextControl>>=
function WebextControl {
    # Called by DebianControlTemplate
    # TB specific, for FF 'web'
    sed --in-place \
    --expression="s/Section: /Section: mail/" ${GitPath}/debian/control

    # 'a' means append. The string after the 'a' will be appended 
    # to the sting before the 'a'.
    # @X escapes the space at the beginning of the appended line.
    # It will be removed later.
    sed --in-place \
    --expression="/Build-Depends: debhelper-compat ${str4versiondebhelpers}/ \
    a @X , zip" \
    ${GitPath}/debian/control
    # TB specific, for FF 'firefox-esr (>= 91.4)'
    sed --in-place \
    --expression="/Depends: \${misc:Depends}/ \
    a @X , thunderbird (>= 1:128.3)" \
    ${GitPath}/debian/control
    sed --in-place --expression="s/^@X//g" ${GitPath}/debian/control
}

<<WebextInstall>>
@

\subsection{\textit{debian/webext-*.install}}
\label{subsec:webext.install}

Für \texttt{Mozilla}-Erweiterungen ist zwingend der folgede Eintrag 
erforderlich:

\begin{verbatim}
 debian/build/<manifest-id>.xpi /usr/share/webext   
\end{verbatim}

<<WebextInstall>>=
function WebextInstall {
    # Called by DisplayDebianFiles
    IdentifyWebextId
    InstallStr="debian/build/"${webextID}".xpi\tusr/share/webext"
    echo -e ${InstallStr} >> ${GitPath}/debian/${PackName}.install
}

<<WebextDocs>>
@

\subsection{\textit{debian/webext-*.docs}}
\label{subsec:webext.docs}

<<WebextDocs>>=
function WebextDocs {
    # Called by
    echo "Still empty"
}

<<WebextLinks>>
@

\subsection{\textit{debian/webext-links-tb}}
\label{subsec:webext.links-tb}

\scriptsize
\begin{verbatim}
 \#       Source                                           Target     
  /usr/share/webext/<manifest.id>.xpi     /usr/lib/thunderbird/extensions/<manifest.id>.xpi
\end{verbatim}
\normalsize

<<WebextLinks>>=
function WebextLinksTB {
    # Called by DisplayDebianFiles
    IdentifyWebextId
    SourceStr="/usr/share/webext/"${webextID}".xpi\t"
    TargetStr="/usr/lib/thunderbird/extensions/"${webextID}".xpi"
    echo -e ${SourceStr}${TargetStr} >> \
    ${GitPath}/debian/${PackName}.links
}

<<webext-plugin-end>>
@

\subsection{Meldung: Webext-Plugin geladen}
\label{subsec:WebextPluginLoaded}

Nun kommt der Schluss dieses Webext-Plugins.

<<webext-plugin-end>>=
whiptail --title "webext plugin found" \
--msgbox "build-gbp-webext-plugin.sh was loaded." 15 60
# This is the end, my friend
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/WebextPluginFound.png} 
\caption{Webext-Plugin wurde geladen}
\end{figure}

\chapter{\texttt{Python}-Plugin}
\label{chap:PythonPlugin}

Das nachstehend dargestellte Plugin erfüllt die besonderen Anforderungen 
beim Bauen von \texttt{Paketen}, die in der Programmiersprache 
\texttt{Python} geschreiben sind. 
(Kapitel~\ref{chap:PythonBauen}, Seite~\pageref{chap:PythonBauen}).

<<build-gbp-python-plugin.sh>>=
#!/usr/bin/bash

# Copyright 2020-2025 Mechtilde and Michael Stehmann <mechtilde@debian.org>
# version 0.9.9

# python plugin for build-gbp.sh

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 31 Milk Street, #960789 Boston,
# MA 02196, USA.

<<python-rulesDH>>
@

\subsection{Meldung: Python-Plugin geladen}
\label{subsec:PythonPluginLoaded}

Nun kommt der Schluss dieses Plugin-Plugins. Es gibt bekannt, dass es 
geladen wurde.

<<IdentifyPythonId>>=
whiptail --title "python plugin found" \
--msgbox "build-gbp-python-plugin.sh was loaded." 15 60

echo "build-gbp-python-plugin.sh was loaded." >> ${log}

<<python-plugin-end>>
@

\begin{figure}[!h]
\centering
\includegraphics[width=25em,height=30ex]{Pictures/PythonPluginFound.png} 
\caption{Python-Plugin geladen}
\end{figure}

\section{Anpassungen für \texttt{Python}-Pakete}
\label{sec:PythonRules}

Hier werden die Besonderheiten für die \texttt{Python}-Paketierung in der 
Datei \textit{debian/rules} abgebildet.

<<python-rules>>=
function PythonRules {
    # Called by DebianRulesTemplate

    # These strings will be added to str4rules
    echo -e "export PYBUILD_NAME="${SourceName}"\n" >> ${GitPath}/Debian/rules
    echo -e "export PYBUILD_SYSTEM=distutils\n" >> ${GitPath}/Debian/rules
}

<<python-control>>
@

<<python-rulesDH>>=
function PythonRulesDH {
    # Called by DebianRulesTemplate

    sed --in-place \
    --expression="s/dh \$@/dh \$@ --with python3 --buildsystem=pybuild/" \
    ${GitPath}/debian/rules

}
<<python-rules>>
@

\section{\textit{debian/control} - Ergänzung für \texttt{Python}-Pakete}
\label{sec:PythonControl}

Hier werden die Besonderheiten für die \texttt{Python}-Paketierung in der 
Datei \textit{debian/control} abgebildet.

<<python-control>>=
function PythonControl {
    # Called by DebianControlTemplate

    # Recent Python version
    PythonVersion=$(py3versions --installed)

    sed --in-place \
    --expression="s/Section:/Section: python/" ${GitPath}/debian/control

    sed --in-place \
    --expression="/Build-Depends: debhelper-compat ${str4versiondebhelpers}/ \
    a , dh-python@X , python3-all@X , python3-setuptools@X\
    #X-Python3-Version: >=${PythonVersion}" ${GitPath}/debian/control

<<python-control1>>
@

Für Tests werden auch die Pakete \textit{python3-distutils} und 
\textit{python3-distutils-extra} als Build-Abhängigkeit benötigt.

<<python-control1>>=
    
    sed --in-place \
    --expression="/Depends: \${misc:Depends}/ \
    a @X , \${python3:Depends}" \
    ${GitPath}/debian/control

    sed --in-place --expression="s/@X/\n/g" ${GitPath}/debian/control
}

<<IdentifyPythonId>>
@

<<python-plugin-end>>=

# This is the end, my friend
@

\chapter{Skripte}
\section{Anlage eines Projektes im Java-Team}
\label{sec:CreateJavaTeam}

Die Anlage eines Projektes im Java-Team, einschließlich der Erlangung 
eines Zugangstokens\index{Zugangstoken}, welches der Variablen 
\textit{SALSA\_TOKEN} im nachfolgenden Skript zuzuweisen ist, wird in 
Kapitel~\ref{sec:JavaTeam} (Seite~\pageref{sec:JavaTeam}) beschrieben.

<<setup-salsa-repository>>=
#!/usr/bin/bash
#
# Setup a new Git repository on Salsa
#
# This script uses the GitLab REST API and requires an access token.
# The token is obtained from the GitLab profile page -> Access Tokens
# (https://salsa.debian.org/profile/personal_access_tokens).
# The token is in the environment variable SALSA_TOKEN
# or has to be sourced from the ~/.salsarc file and assigned
# to the SALSA_TOKEN variable:
#
# This is the Token for jollyday-java
#  SALSA_TOKEN="KyuZRyWTTxfddcGcyphN"
#

set -eu
<<setup-salsa-repository3>>
@

Das Paket \textit{jq} muss auf der lokalen Maschine installiert werden.

<<setup-salsa-repository3>>=

if ! which jq >/dev/null
then
    echo "You need to apt install jq" >&2
    exit 1
fi

<<setup-salsa-repository5>>
@

Der Aufruf erfolgt mit der Angabe des \textit{SourceName}.

<<setup-salsa-repository5>>=
if [ -z "$1" ]; then
    echo "Usage: ./setup-salsa-repository <packagename>"
    exit 1;
fi

check_return_code() {
    if [ $? -ne 0 ]; then
        echo
        echo "Something went wrong!"
        exit 1
    fi
}

test -n "$SALSA_TOKEN" || . ~/.salsarc

PACKAGE=$1

SALSA_URL="https://salsa.debian.org/api/v4"
SALSA_GROUP=java-team
SALSA_GROUP_ID=2588

<<setup-salsa-repository8>>
@

Nun wird das Repositorium auf \textit{salsa.debian.org} angelegt.

<<setup-salsa-repository8>>=
# ----------------------------------------------------------------------

echo "Creating the ${PACKAGE} repository..."

RESPONSE=$(curl -s "$SALSA_URL/projects?private_token=$SALSA_TOKEN" \
  --data "path=$PACKAGE&namespace_id=\
  $SALSA_GROUP_ID&visibility=public&issues_enabled=false&snippets_enabled=false&wiki_enable\
  d=false&jobs_enabled=false&printing_merge_request_link_enabled=false")

echo $RESPONSE | jq --exit-status .id > /dev/null
check_return_code

PROJECT_ID=$(echo $RESPONSE | jq '.id')
<<setup-salsa-repository10>>
@

Nun wird das ausstehende BTS-Tag-Hook konfiguriert.

<<setup-salsa-repository10>>=
# ----------------------------------------------------------------------

echo "Configuring the BTS tag pending hook..."

TAGPENDING_URL="https://webhook.salsa.debian.org/tagpending/$PACKAGE"
curl --silent --output /dev/null -XPOST --header "PRIVATE-TOKEN: $SALSA_TOKEN" \
$SALSA_URL/projects/$PROJECT_ID/hooks \
     --data "url=$TAGPENDING_URL&push_events=1&enable_ssl_verification=1"
check_return_code

# ----------------------------------------------------------------------

echo "Configuring the KGB hook..."

KGB_URL="http://kgb.debian.net:9418/webhook/?channel=debian-java\
%26network=oftc%26private=1%26use_color=1%26use_irc_notices=1%26squash_threshold=20"
curl --silent --output /dev/null -XPOST --header "PRIVATE-TOKEN: $SALSA_TOKEN" \
$SALSA_URL/projects/$PROJECT_ID/hooks \
     --data "url=\
     $KGB_URL&push_events=yes&issues_events=yes&\
     merge_requests_events=yes&tag_push_events=\
     yes&note_events=yes&job_events=yes&pipeline_events=yes&\
     wiki_events=yes&enable_ssl_verification=yes"
check_return_code

# ----------------------------------------------------------------------

echo "Configuring email notification on push..."

curl --silent --output /dev/null -XPUT --header "PRIVATE-TOKEN: $SALSA_TOKEN" \
$SALSA_URL/projects/$PROJECT_ID/services/emails-on-push \
     --data "recipients=pkg-java-commits@lists.alioth.debian.org \
     dispatch@tracker.debian.org"
check_return_code

# ----------------------------------------------------------------------

echo
echo "Done! The repository is located at ${SALSA_URL%/api*}/$SALSA_GROUP/$PACKAGE"
@

\section{Skript zum Extrahieren der Dokumentation im PDF- und Epub-Format}
\label{sec:CreateBook}

Dieses Skript dient dazu, lesbare Dokumente zu erstellen.

\subsection{Abhängigkeiten}
\label{subsec:BookDependencies}

Folgende Pakete müssen installiert sein, damit das Skript lauffähig ist.

\begin{itemize}
    \item noweb
    \item texlive
    \item texlive-latex-extra
    \item texlive-extra-utils
    \item biber
    \item texlive-lang-japanese (für die Datei ifptex.sty)
    \item tidy (für das EBook)
    \item texlive-lang-german - für die deutschsprachige Dokumentation
    \item texlive-lang-english - für die englische Übersetzung
    \item texlive-lang-french - für die französische Übersetzung
\end{itemize}

\subsection{Ablauf}

Zunächst werden mit dem Skript aus den *.nw-Dokumenten *.tex-Dokumen\-te 
erzeugt.

Das folgende Skript kann mit

\begin{verbatim}
    notangle -Rcreate-book.sh Part6.nw > create-book.sh &&
    t=$(date +%c)
    echo "#generated on $t" >> create-book.sh
    chmod ugo+x create-book.sh
\end{verbatim}

aus der Datei \textit{Part6.nw} extrahiert werden.

<<create-book.sh>>=
#!/usr/bin/bash

#set -e

BasePath=$(pwd)

LANGS="en_US"

noweave -index -delay BuildWithGBP.nw > BuildWithGBP.tex # contains preamble
noweave -index -delay Title.nw > GBP-Title.tex
noweave -index -delay Part1.nw > GBP-Part1.tex
noweave -index -delay Part2.nw > GBP-Part2.tex
noweave -index -delay Part3.nw > GBP-Part3.tex
noweave -index -delay Part4.nw > GBP-Part4.tex
noweave -index -delay Part5.nw > GBP-Part5.tex
noweave -index -delay Part6.nw > GBP-Part6.tex

#noweave -filter l2h -index -html BuildWithGBP.nw | htmltoc > BuildWithGBP.html

<<create-book.sh1>>
@

Diese wird dann zu *.pdf- und *.epub-Dokumente umgewandelt. Das 
Stichwortverzeichnis darf nur einmal erstellt werden und zwar nach der
ersten Ausführung von \textit{pdflatex}. Mehrfache Ausführung erzeugt
zu hohe Seitenzahlen.

<<create-book.sh1>>=
#if [ -f BuildWithGBP.aux ]
#then
   #rm BuildWithGBP.aux
#fi

for ((i=4; i>0; i--))
do
    echo $i
    pdflatex -shell-escape BuildWithGBP.tex

    # Create Index only one time
    # Otherwise you get wrong page numbers
    if [ i=4 ]
    then
        makeindex BuildWithGBP
    fi

    # Create Bibliography
    biber BuildWithGBP
done

<<create-book.sh5>>
@

Das EPUB-Format ist ein gezipptes XHTML, angereichtert mit Metadaten.

<<create-book.sh5>>=
# tex4ebook -f mobi BuildWithGBP.tex
# tex4ebook -f epub BuildWithGBP.tex ../

if ls | grep --quiet '\.html'
then
    rm *.html
fi

<<create-book.sh6>>
@

<<create-book.sh6>>=

# For the first translation

for lang in ${LANGS}
do
    cd translation/${lang}/target

    #sed --in-place --expression 's/^%+-.*//' GBP-Part3.tex
    sed --in-place --expression ':a;N;$!ba;s/_ \n\n%/_%/' GBP-Part3.tex

<<create-book.sh7>>
@

Mit dem regülären Ausdruck werden folgende Anpassungen in der Datei
\textit{GBP-Part3.tex} vorgenommen.


% Es ist zu prüfen, wie VOR einer einmal oder mehrfach vorkommende Gruppe
% von Leerzeichen ein einfacher, gegebenenfalls weicher Zeilenumruch
% eingefügt werden kann.

% Es ist auch zu prüfen, wie dies in die Segmentierungsregen eingefügt
% werden kann

% vielleicht kann ja auch ein Script darüber laufen, dass für die
% Code-Chunks ein Absatzende Zeichen einfügt, damit \textit{OmegaT} dies 
% selber korekt setzen kann.

Das \textit{\$-Zeichen} steht für das Zeilenende.

<<create-book.sh7>>=

    if [ -f BuildWithGBP.aux ]
    then
        rm BuildWithGBP.aux
    fi

    for ((i=4; i>0; i--))
    do
        pdflatex -shell-escape ./BuildWithGBP.tex
        if [ i=4 ]
        then
            makeindex BuildWithGBP
        fi

        # Create Bibliography
        biber BuildWithGBP
    done
    cd ${BasePath}
done

# Remove auxillary *.html files which are needed for epub
#if ls | grep --quiet '\.html'
#then
#    rm *.html
#fi

@

\section{Skript zum Extrahieren der Skripte}
\label{sec:CreateBuildscript}

Das folgende Skript kann mit

\begin{verbatim}
   notangle -Rcreate-buildscript.sh Part6.nw > create-buildscript.sh &&
   t=$(date +%c)
   echo "#generated on $t" >> create-buildscript.sh
   chmod ugo+x create-buildscript.sh
\end{verbatim}

aus der Datei \textit{Part6.nw} extrahiert werden.

<<build-script>>=
#!/bin/bash

set -e

scripts="
  build-gbp.sh
  build-gbp-java-plugin.sh
  build-gbp-maven-plugin.sh
  build-gbp-webext-plugin.sh
  build-gbp-python-plugin.sh
"
cat Title.nw Part1.nw Part2.nw Part3.nw Part4.nw Part5.nw Part6.nw > BuildWithGBPg.nw  
notangle -Rbuild-gbp.sh BuildWithGBPg.nw > build-gbp.sh &&
#t=$(date +%c)
# For building reproducible
t=$(date --utc --date="@${SOURCE_DATE_EPOCH:-$(date +%s)}" -R)

function build_script()
{
  notangle -R"$script" BuildWithGBPg.nw > "$script"
  sed --in-place \
  --expression='s/This is the end, my friend[[:cntrl:]]*/This is the end, my friend/' \
  "$1"
  echo "#generated on $t" >> "$1"
  chmod ugo+x "$1"
  bash -n "$1"
}

for script in $scripts; do
   build_script "$script"
done

# Remove auxillary file BuildWithGBPg.nw
rm BuildWithGBPg.nw

@

Mittels des Befehls \textit{noweave}\index{noweave} werden die 
deutschsprachigen \textit{*.nw}-Dateien in 
\textit{*.tex}-Dateien\index{\TeX{}-Dateien} umgewandelt. 

<<CreateTexFromNW>>=
function CreateTexFromNW {
    # Called by TaskSelect
    # Create *.tex files from *.nw files

    cd ${SRCDIR}

    noweave -index -delay BuildWithGBP.nw > BuildWithGBP.tex # contains preamble
    noweave -index -delay Title.nw > GBP-Title.tex
    noweave -index -delay Part1.nw > GBP-Part1.tex
    noweave -index -delay Part2.nw > GBP-Part2.tex
    noweave -index -delay Part3.nw > GBP-Part3.tex
    noweave -index -delay Part4.nw > GBP-Part4.tex
    noweave -index -delay Part5.nw > GBP-Part5.tex
    noweave -index -delay Part6.nw > GBP-Part6.tex
<<CreateTexFromNW1>>
@

Eine eventuell vorhandene Datei \textit{BuildWithGBP\_html.tex} wird 
entfernt.

<<CreateTexFromNW1>>=

    if [ -f BuildWithGBP_html.tex ]
    then
        rm BuildWithGBP_html.tex
    fi
}
@

\section{\textit{gitlab-ci.yml} für die Salsa-CI}
\label{sec:gitlab-ci.yml}

<<gitlab-ci.yml>>=
variables:
  DEPS: file make texlive noweb texlive-bibtex-extra texlive-lang-german
        texlive-lang-japanese texlive-latex-extra texlive-binaries
        texlive-extra-utils biber tidy texlive-lang-english

stages:
  - build
  - deploy

build:
  stage: build
  image: debian:sid
  before_script:
    - apt -y update
    - apt -y install $DEPS
  script:
    - make
  artifacts:
    paths:
      - '*.pdf'
      - '*.epub'
      - 'build-gbp-python-plugin.sh'
      - 'build-gbp-maven-plugin.sh'
      - 'build-gbp-webext-plugin.sh'
      - 'build-gbp.sh'
      - 'build-gbp-java-plugin.sh'
      - 'translation/en_US/target/*.pdf'

pages:
  stage: deploy
  image: debian:sid
  needs:
    - build
  script:
    - mkdir -p public/de
    - mkdir -p public/en_US
    - cp *.pdf *.epub build-gbp*.sh public/
    - cp *.tex public/de/
    - cp translation/en_US/target/*.pdf public/en_US/

  artifacts:
    paths:
      - public
  only:
    - master
@