[RESOLU] comportement incompréhensible sur script

AGPArchitecture · Le 18/05/2019, à 15:46

Bonjour à tous j'ai le petit script ci-après qui me fait quelque chose que je ne comprend pas:

#!/bin/bash

debug=0
dossierFinal=""
traiterContenu=0

Debug () # debug on/off - continuer on/off - message
{
	if [ $debug -ne 0 ]; then return 0; fi
	
	local continue=$2; shift; shift

	echo -e -n "\033[1;34mDebug :\033[0m \n $* \n"

	if [ $continue -eq 0 ]; then
		read -p $'\e[1;30m \t Continuer Debug (taper n pour arrêter)? \e[0m: \n' -n 1 -r
		
		if [[ $REPLY =~ ^[nN]$ ]]; then
			echo "Script arreté"
			exit 1
		fi
	fi
	
	return 0
}


function Dir2cbz ()
{
	local dossierATransformer="$1" 					
	local nomDossier=$(basename "$1")
	local nomEbook="$nomDossier.cbz"

	#creation du chemin
	if [ -z "$dossierFinal" ]; then	
		nomEbook="$PWD/$nomEbook"
	else	
		nomEbook="$dossierFinal/$nomEbook"
	fi	
	
	Debug $debug 0 "Chemin de l'ebook : $nomEbook"
	
	return 0
}


for arg in "$@"; do

	echo "--------------  Traitement de $arg --------------"

	if [ -d "$arg" ]; then
		dossierATraiter=$(realpath "$arg")
		echo "Dossier à traiter : $dossierATraiter"
		
		if [ $traiterContenu -eq 0 ]; then
			cd "$dossierATraiter"
			find "$dossierATraiter" -mindepth 1 -maxdepth 1 -type d -print0 |
			while IFS= read -r -d '' dos; do
				echo "---------------------------------------------"
				echo " ---> $dos "
				Dir2cbz "$dos"
				
			done
		fi
	fi

done

exit 0

qui me donne le résultat suivant :

> test.sh /media/Datas/Livre/Complet/Projet\ 01/
--------------  Traitement de /media/Datas/Livre/Complet/Projet 01/ --------------
Dossier à traiter : /media/Datas/Livre/Complet/Projet 01
---------------------------------------------
 ---> /media/Datas/Livre/Complet/Projet 01/01 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/01.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/02 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/02.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/03 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/03.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/04 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/04.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/05 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/05.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/06 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/06.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/07 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/07.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/08 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/08.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/09 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/09.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/10 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/10.cbz 
---------------------------------------------
 ---> media/Datas/Livre/Complet/Projet 01/11 
Debug : 
 Chemin de l'ebook : /media/Datas/Livre/Complet/Projet 01/11.cbz

ce que je ne comprend pas c'est ou est passé le slash avant le media

 ---> media/Datas/Livre/Complet/Projet 01/10

de la ligne de code

echo " ---> $dos "

par contre si j'enlève la ligne suivante :

Debug $debug 0 "Chemin de l'ebook : $nomEbook"

le problème ne se pose plus....

Quelqu'un peut m'expliquer l'erreur et le pourquoi?

merci

Dernière modification par AGPArchitecture (Le 21/05/2019, à 18:47)

pingouinux · Le 18/05/2019, à 16:41

Bonjour,
Vraisemblablement, la cause en est que l'entrée standard du read -p ..., dans la fonction Debug, est la sortie standard du find, et tu lis le premier caractère du chemin suivant. Tu peux d'ailleurs constater que le premier chemin est correct.
Il faudrait utiliser un "file descriptor" dans le read -p (paramètre -u).

Je n'ai plus la syntaxe en tête, je regarderai plus tard, si quelqu'un d'autre ne t'a pas donné la solution avant..

pingouinux · Le 18/05/2019, à 17:06

Il y a sans doute plus simple, mais tu peux essayer ceci, qui passe par l'intermédiaire d'un fichier temporaire :

..............................................
                        find "$dossierATraiter" -mindepth 1 -maxdepth 1 -type d -print0 >/tmp/temporaire
                        while IFS= read -u 3 -r -d '' dos; do
                                echo "---------------------------------------------"
                                echo " ---> $dos "
                                Dir2cbz "$dos"
                                
                        done 3</tmp/temporaire
..............................................

Watael · Le 18/05/2019, à 17:47

salut,

le slash n'est que lorsque le chemin n'est pas entre guillemets.
ça ne devrait pas causer d'erreur.

et ce n'est pas plus simple d'utiliser un fichier temporaire, ça ralentit le script.
il n'y a pas de "read imbriqués", donc le recours à un descripteur de fichier est aussi inutile.

PS: "esthétiquement", pour une meilleure lisibilité, j'écris :

longueCommande \
   | autreLongueCommande

EDIT:

(( $debug )) && Debug 0 "$nomEbook"

il faut bien sûr modifier la fonction debug en conséquence

Dernière modification par Watael (Le 18/05/2019, à 17:58)

pingouinux · Le 18/05/2019, à 18:54

@AGPArchitecture :
Et sans fichier temporaire :

..............................................
			cd "$dossierATraiter"
                        while IFS= read -u 3 -r -d '' dos; do
                                echo "---------------------------------------------"
                                echo " ---> $dos " 
                                Dir2cbz "$dos"
                                
                        done 3< <(find "$dossierATraiter" -mindepth 1 -maxdepth 1 -type d -print0)                            
..............................................

Watael · Le 18/05/2019, à 19:13

il n'y a pas de "read imbriqués", donc le recours à un descripteur de fichier est aussi inutile.

EDIT: ah, si, je viens de voir dans la fonction Debug(), il y a un read.
alors, c'est ce read là qu'il faut adapter :

read -p $'\e[1;30m \t Continuer Debug (taper n pour arrêter)? \e[0m: \n' -n 1 -r  </dev/tty

</EDIT>

mais il n'est pas dit que le script échoue, mais seulement que l'affichage ne correspond pas à l'argument passé.
ceci est dû aux guillemets.

PS: cd aussi est inutile.

je ne sais même pas certain si la boucle while est indispensable.
pourquoi ne pas passer par -execdir ?

Dernière modification par Watael (Le 18/05/2019, à 19:23)

AGPArchitecture · Le 19/05/2019, à 12:11

Merci pour l'aide je dois donc adapter mon read de la fonction Debug parce que 'entrée standard du read -p ..., dans la fonction Debug, est la sortie standard du find

Ok mais pourriez-vous m'éclairer sur ce qu'est l'entrée standard et la sortie standard?

@ watael:
le script plantait bien et il ne s'agissait pas que de l'affichage.
Je suis d'accord que le code proposé initialement est sûrement simplifiable mais je ne me voyait pas vous fournir l'ensemble du script afin de trouver d'ou venant l'erreur. J'ai donc essayé d'isolé l'erreur.

@pingouinux
je voulais justement essayer de ne pas passer par un fichier et tes codes ne classe pas dans un ordre les fichiers envisagés

pour info complémentaires:

voici l'ensemble du script recrée depuis un cat des différents fichiers (je me voyais mal vous fournir ca et vous dire ca plante! que faire?)
maintenant je suis preneur de toute remarque sur l'ensemble du script (grand merci à celui qui prendra le courage de l'analyser) pour améliorer le code et continuer mon apprentissage du bash.

CODE COMPLET

#!/bin/bash

#set -o pipefail #
#set -e #
#set -E #

######################################
# Fichier Common.sh
######################################

COMMON=0

debug=0
confirmersuitedebug=0
verbose=0
affichererreur=0



Show () #verbose on/off - debug on/off - message
{
	local verbose=$1
	local debug=$2
	shift; shift
	
	if [ $verbose -eq 0 ] || [ $debug -eq 0 ]; then
		echo -e "$*"
	fi
	
	return 0
}

Debug () # debug on/off - continuer on/off - message
{
	if [ $1 -ne 0 ]; then return 0; fi
	
	local continue=$2; shift; shift

	echo -e -n "\033[1;34mDebug :\033[0m \n $* \n"

	if [ $continue -eq 0 ]; then
		read -p $'\e[1;30m \t Continuer Debug (taper n pour arrêter)? \e[0m: \n' -n 1 -r # TODO faire inverse avec coontinuer sur o(ui) ou y(es)
		
		if [[ $REPLY =~ ^[nN]$ ]]; then
			echo "Script arreté"
			exit 1
		fi
	fi
	
	return 0
}

Erreur () #afficher on/off - Erreur bloquante on/off - message d'erreur
{
	local afficher=$1
	local bloquante=$2
	shift; shift
	
	if [ $afficher -eq 0 ]; then
		echo -e "\033[41;1mUne erreur est survenue :\033[0;1m $* \e[0m" >&2
	fi
	
	if [ $bloquante -eq 0 ]; then
		exit 1
	fi
	
	return 0
}

#==============================
# Dossier de base
#==============================

mainpathscript="$( cd "$(dirname "$0")" ; pwd -P )" #Chemin absolu #"$(dirname $0)"

if [ "$mainpathscript" = "." ]; then
	mainpathscript="$PWD"
fi

#==============================
# Gestion import
#==============================

declare -A import

Import ()
{
	local erreurimport=0

	for arg in $*
	do	
		#TODO: Vérifier si import déjà effectué
		# if [ $import[$arg] = "" ]; then #comparaison en string si pas encore défini -> evite erreur si vérification sur int.
			if [ -f "$mainpathscript/$arg" ]; then
				. "$mainpathscript/$arg"
				import[$arg]=OK
				Debug $debug 1 "Importé : $arg"
			else
				Erreur "Fichier $1 manquant/introuvable"
				$listerreurs[$erreurimport]="$1"
				erreurimport=1
			fi
		#else
		#	Debug "$arg déjà importé"		
		#fi
	done
	
	if [ $erreurimport -ne 0 ]; then
		printf '%s\n' "$listerreurs[@]"
		exit 1
	fi
}

CheckPaquets ()
{
	local missingpaquets=""
	local nbmanquant=0

	for paquets in $@; do

		which $paquets > /dev/null
		
		if [ $? -ne 0 ]; then
			((nbmanquant++))
			missingpaquets="$missingpaquets $paquets"
		fi		
		
	done
		
	if [ $nbmanquant -ne 0 ]; then
		echo -e "$nbmanquant paquets sont manquants pour l'execution du script"
		echo "Veuillez installer : $missingpaquets"
		exit 1
	fi
	
	return 0
}


AfficherAide ()
{
	echo "AFFICHEUR D'AIDE A FAIRE"
	return 1
}

confirmation ()
{
	if [ $confirmchoix -eq 1 ]; then 
		echo "$1"
		
		regex="^[Oo]([Uu][Ii])?$"
		read -p "Doit-on faire la sauvegarde ? (o/n) : " maj
		if [[ "$maj" =~ $regex ]]; then
			exit 0
		else
			exit 1
		fi
	fi
}

STOP ()
{

  local frame=0
  
  while caller $frame; do
    ((frame++));
  done
  
    echo "[$( caller )] $*" >&2
    echo "BASH_SOURCE: ${BASH_SOURCE[*]}"
    echo "BASH_LINENO: ${BASH_LINENO[*]}"
    echo "FUNCNAME: ${FUNCNAME[*]}"    
  
	echo -e "\033[41;1mSTOP :\033[0;1m $* \e[0m" >&2

	exit 1
}



#####################################
# fichier FileDirTools 
#####################################

# vérification que common.sh est bien importé pour les sous fonctions
if [ -z "$COMMON" ]; then
	echo -e -n "\n \033[41;1m ERREUR PAS DE FICHIER \"Common.sh\" IMPORTE DANS LE SCRIPT \e[0m \n" && exit 1
fi

CreateWorkDirectory () #dossier à crée - message
{
	if [ -d "$1" ]; then
		return 1
	fi
	
	mkdir -p "$1"
	return $?
}

MouveWithIndex () #Fichier - Dossier de destination
{
	local notimagefile="$1"
	local nomfichier=$(basename "$notimagefile")
	local nom="${nomfichier%.*}"
	local ext="${nomfichier##*.}"
	local newname="$nom.$ext"
	local i=1
	
	while [ -f "$2/$newname" ]
	do
		newname="$nom ($i).$ext"
		((i++)) # TODO: eventuellement clore la boucle si maximum de 3.000 Par exemple pour eviter boucle infinie
	done

	mv "$notimagefile" "$2/$newname"
	
	return $?
}

CleanCache ()
{
	Show  $verbose $debug "Nettoyage du dossier"
	
	find "$1" -type f -name "Thumbs.db" -delete -print0
	find "$1" -type f -name ".DS_Store" -delete -print0 
	find "$1" -type d -name "__MACOSX" -delete -print0
	find "$1" -empty -delete -print0
	
	return 0
}

SetToRacine () #dossier à préparer      # TODO : prévoir renommage quand même si pas de sous-dossier et ajouter un temp
{
	local dossier="$1"
	local nb=0
	local ret=0
	
	if [ $(find "$dossier" -mindepth 1 -type d | wc -l) -eq 0 ]; then
		return 0
	fi
	
	local i=0
	find "$dossier" -type f -print0 | sort -d -z | #--numeric-sort --zero-terminated | #sort -z -d | 
	while IFS= read -r -d '' fi; do
	
		ext=${fi##*.}
		numero=$(printf "%03d" $i)
	
		mv "$fi" "$dossier/temp-$numero.$ext"  #${nomfichier%.*}-$i.$ext" # TODO : vérifier avant de confirmer.......
		((i++))
		
	done

	find "$dossier" -mindepth 1 -type d -empty -delete
	if [ $(find "$dossier" -mindepth 1 -type d | wc -l) -ne 0 ]; then
		Erreur 0 1 "$dossier : Il reste des dossiers impossible à traiter"
		ret=1
	fi

	return $ret
}

RemoveNotImage () #Dossier à analyser - Dossier ou deplacer    -> ne peut contenir QUE des fichiers de type image
{	
	if [ $(find "$1" -maxdepth 1 -type d | wc -l) -ne 1 ]; then # si contient un dossier ne pas traiter -ne 1 car dossier compté
		Show $verbose $debug "contient un/des dossier(s) : $1 ne peut être traité" # TODO: Erreur plutot que show
		return 1
	fi
	
	find "$1" -mindepth 1 -type f -name "*.*" -print0 | sort -z -d |
	while IFS= read -r -d '' fichier; do

		if [ $(file -i "$fichier" | grep -v 'image' | wc -l ) -ne 0 ]; then
		
			MouveWithIndex "$fichier" "$2"
		
			if [ $? -ne 0 ]; then
				echo -e "\033[41;1mUne erreur est survenue :\033[0;1m $* \e[0m:"
				return 1
			fi
			
			Show $verbose $debug "$fichier n'est pas une image : deplacement"
		fi
		
	done

	return 0
}

NettoyageNom () # nom à nettoyer - première lettre en majuscule on/off
{
	local nom=$(basename "$1")
		
	nom="$(sed 's#.*/##;s#([^)]*)##g' <<< $nom)" #supprime entre parenthese
	nom="$(sed 's#\[[^]]*\]##g' <<< $nom)" # supprime entre crochet
	nom="$(sed 's#{[^}]*}##g' <<< $nom)" #supprime entre accolade
	nom="$(sed 's#[+=*?\!]##g' <<< $nom)" # supprime caractère spécaiux sauf -
	nom="$(sed 's#[àâä]#a#g' <<< $nom)" #rempace âà par a
	nom="$(sed 's#[éèêë]#e#g' <<< $nom)" 
	nom="$(sed 's#[ûùü]#u#g' <<< $nom)"
	
	nom=$(echo "$nom" | tr -s " ")
	nom=${nom%% }
	nom=${nom## }
	
	if [ "$2" -eq 0 ]; then
		nom="$(sed 's/^.\| [a-z]/\U&/g' <<< $nom)" #première lettre mot en majuscule
	fi
	
	echo "$nom"
}


RemoveNotImage_NEW () #Dossier à analyser - Dossier ou deplacer    -> ne peut contenir QUE des fichiers de type image
{
	Show  $verbose $debug "Verification image"

	find "$1" -mindepth 1 -type f -name "*.*" -print0 | sort -z -d |
	while IFS= read -r -d '' fichier; do

		if [ $(file -i "$fichier" | grep -v 'image' | wc -l ) -ne 0 ]; then
		
			MouveWithIndex "$fichier" "$2"
		
			if [ $? -ne 0 ]; then
				echo -e "\033[41;1mUne erreur est survenue :\033[0;1m $* \e[0m:"
				return 1
			fi
			
			Show $verbose $debug "$fichier n'est pas une image : deplacement"
		fi
		
	done

	return 0
}



# donne un nom provisoire au fichier avant de les renommer pour être sur qu'il n'y a pas de fichier existant
# ATTENTION ; system en récursif -> traite tous les sous dossier
temprename () #Dossier
{
	
	if [ ! -d "$1" ]; then
		Erreur 0 1 "$1 n'est pas un dossier"; return 1 		
	fi
	
	local nouveaufichier=""
	
	find "$1" -type f -print0 | sort -z -d | #--numeric-sort --zero-terminated
	while IFS= read -r -d '' fichier; do		
	
		nouveaufichier=$(basename "$fichier")
		nouveaufichier="tempEbook-$nouveaufichier"	
		dossier=$(dirname "$fichier")	
	
		if [ -f "$dossier/$nouveaufichier" ]; then
			Erreur 0 1 "Un fichier existe déjà" >&2; return 2
		fi	
	
		mv "$fichier" "$dossier/$nouveaufichier"
		
	done
	
	return 0
}


New_TEST_RenamePage () # Dossier dont les fichiers doivent être renommé - nom dossier facultatif
{
	Show  $verbose $debug "Renommage des pages"
	
	local nompages=""
	
	if [ -z "$2" ]; then # si pas de nom -> on ne renomme pas
		Show $verbose $debug 1 "Pas de nom de page défini"; return 0	
	fi
	
	if [ ! -d "$1" ]; then
		Erreur 0 1 "$1 n'est pas un dossier"; return 1 		
	fi
	
	# generation du nom
	if [ "$2" == '*DIRN*' ]; then
		nompages=$(basename "$1")
		nompages=$(NettoyageNom "$nompages")
		nompages=$(sed 's/\ //g' <<< "$nompages")

	elif [ "$2" == '*DIR*' ]; then 
		nompages=$(basename "$1")
	
	else
		nompages="$2"
	
	fi
	
	temprename "$1" || return 2
	
	local i=1
	local dossier=""
	local ext=""
	local nouveaunom=""	
	
	find "$1" -type f -print0 | sort -z -d | #--numeric-sort --zero-terminated
	while IFS= read -r -d '' page; do	
	
	   	ext=${page##*.}; ext=${ext,,}	
		nouveaunomfichier="$nompages-$(printf "%03d" $i).$ext"	
		dossier=$(dirname "$page")	

		if [ -f "$dossier/$nouveaunomfichier" ]; then
			Erreur 0 1 "Un fichier existe déjà" >&2; return 2
		fi
		
		mv "$page" "$dossier/$nouveaunomfichier"
		
		((i++))
		
	done

	return 0
}

function Backup () #Dossier à backuper - emplacement du backup
{
	Show  $verbose $debug "Backup du dossier $1 vers $2"
	
	local bckp=""
	local nomdossier=$(basename "$1")
	
	if [ -z "$2" ]; then
		bckp="$PWD/$nomDossier-BCKP"
	else
		bckp="$2/$nomDossier"
	fi
		
	if [ -d "$bckp" ]; then
		Erreur 0 1 "Impossible de faire le backup : Un dossier existe dejà"
		return 1
	fi

	cp -r "$1" "$bckp" 
	
	if [ $? -ne 0 ]; then
		Erreur 0 0 "Erreur lors de la création du backup"
		if [ -d "$bckp" ]; then
			rm -r "$bckp"
		fi
		return 2
	fi

	return 0
}

######################################
# fichier : EbookTools
######################################

# vérification que common.sh est bien importé pour les sous fonctions
if [ -z "$COMMON" ]; then
	echo -e -n "\n \033[41;1m ERREUR PAS DE FICHIER Common.sh IMPORTE DANS LE SCRIPT \e[0m \n" && exit 1
fi

CheckPaquets unzip unrar

ExtraireEbook () # Fichier ebook + dossier ou extraire
{
	local ebook="$1"									#Debug $debug $confirmersuitedebug "$ebook"
	local nomfichier=$(basename "$ebook")				#Debug $debug $confirmersuitedebug "$nomfichier"
	local dossierextraction="$2" #/${nomfichier%.*}"	#Debug $debug $confirmersuitedebug "$dossierextraction"
	local ext=${nomfichier##*.}							#Debug $debug $confirmersuitedebug "$ext"
	local extractOK=0
	local erreur=""

	if [ -d "$dossierextraction" ]; then
		Erreur 0 1 "$nomfichier : impossible d'extraire - Dossier déjà existant"
		extractOK=1
		return 1
	fi
	
	if [ ! -d "$dossierextraction" ]; then 
	
		mkdir -p "$dossierextraction" || erreur="Impossible de créer le dossier d'extraction" # TODO Prevoir vérification que mkdir a bien été effectué
	
		case "${ext,,}" in #TODO: voir si pas mieux avec file....
	
			"cbz" | "zip")
				unzip -qq "$ebook" -d "$dossierextraction"
				if [ $? -ne 0 ]; then
					erreur="$ebook : Erreur lors de l'extraction"
				fi
			;;
			
			"cbr" | "rar")
				unrar x "$ebook" "$dossierextraction" > /dev/null
				if [ $? -ne 0 ]; then
					erreur="$ebook : Erreur lors de l'extraction"
				fi
			;;
				
			*)
				erreur="Fichier $nomfichier de type $ext : non traité"
			;;
			
		esac	
	
		if [ -n $erreur ]; then # vrai si chaine vide
			extractOK=0
		else
			Erreur 0 1 $erreur
			if [ -d "$dossierextraction" ]; then
				rm -d "$dossierextraction"
			fi
			extractOK=2
		fi
	fi
	
	return $extractOK
}

CreateCbz () # Dossier à zipper - ebook avec son chemin - conserver structure dans l'archive on/off
{
	local nomebook=$(basename "$1")
	local cbz="$2"
	local conserverstructure=0
	
	Show $verbose $debug "Création du fichier zip : $cbz"
	
	if [ -f "$cbz" ]; then
		Erreur 0 1 "Un fichier ebook \"$nomebook.cbz\" existe déjà"
		return 1
	fi	
	
	if [ ! -z $3 ]; then
		conserverstructure=$3
	fi	
	
	oldpwd="$PWD" # on change de dossier pour ne pas zipper tous les dossier de l'arborescence 
	cd "$1"
	cd ".."
	
	local temp=$(realpath --relative-to="$PWD" "$1")
	
	#Debug 0 0 "$PWD \n $1 \n $temp"
		
	if [ $conserverstructure -eq 0 ]; then
		zip -rqj "$cbz" "$temp" > /dev/null # option j supprimer les dossiers lors de l'archivage
	else
		zip -rq "$cbz" "$temp" > /dev/null
	fi
		
	if [ $? -ne 0 ]; then
		if [ -f "$2/$nomebook.cbz" ]; then
			rm -rf "$2/$nomebook.cbz"
		fi
		return 2
	fi
	
	cd "$oldpwd"

	return 0
}

######################################
# fichier Getopts
######################################

arguments=""

dossierBackup=""		#B
dossierFinal=""			#F
dossierNonImage=""		#N
dossierTemporaire=""	#T

afficheErreur=1			#a
effectuerBackup=1		#b
nettoyerCache=1			#c
confirm=1				#C
effaceDossier=1			#e
traiterContenu=1		#g
imageSeulement=1		#i
nomPages=""				#p
nomEbook=""				#n:
restructurerDossier=1	#r

verbose=1				#v
debug=1					#D
confirmerDebug=1		#Y



while getopts "B:F:N:abcCeghip:n:rvDY-:" option; do

	arguments="$arguments -$option \"$OPTARG\" "

	case "$option" in
	
		#-) # option longue ->> --option=arg
		#	while IFS="=" read option arg; do
		#		case "$OPTARG" in
		#			effacer)
		#				echo "Option: $option"
		#				echo "Arg:       $arg"
		#			;;
		#			*)
		#				    echo "Option: $option"
		#					echo "Arg:       $arg"
		#				;;
		#			esac
		#		done
		#	;;
		
		B)
			dossierBackup="$OPTARG"
			;;
		F)
			dossierFinal="$OPTARG"
			;;
		N)
			dossierNonImage="$OPTARG"
			;;			
		T)
			dossierTemporaire="$OPTARG"
			;;
			
		a)
			afficheErreur=0
			;;
		b)
			effectuerBackup=0
			;;
		c)
			nettoyerCache=0
			;;
		C)
			confirm=0
			;;
		e)
			effaceDossier=0
			;;
		g)
			traiterContenu=0
			;;
		h)
			AfficherAide $(dirname "$0")
			exit 0
			;;
		i)
			imageSeulement=0
			;;
		p)
			nomPages="$OPTARG"
			;;
		n)	
			nomEbook="$OPTARG"
			;;
		r)
			restructurerDossier=0
			;;
		
		v)
			verbose=0
			;;
		D)
			debug=0
			;;
		Y)
			debug=0
			confirmerDebug=0
			;;

		*)
            Erreur 0 0 "Option $option inconnue"
            ;;
        :)
            Erreur 0 0 "L'option $option requiert un argument"
            ;;
        \?)
            Erreur 0 0 "option interdite : $option - $OPTARG"
            ;;
    esac
    
done

Debug $debug 1 "Paramètres de commandes : $*"

shift $((OPTIND-1)) #nettoyage des options du script


Debug $debug 1 "arguments = $arguments \n dossier backup : $dossierBackup \n dossier final : $dossierFinal \n dossier temporaire : $dossierTemporaire \n dossir fichier non image : $dossierNonImage \n nom ebook : $nomEbook \n nom des pages : $nomPages"



Debug $debug 1 "Verification compatibilité entre options"

getoptsErreur=1

if [ $# -gt 1 ]; then

	if [ ! -z "$nomEbook" ] && [ "$nomEbook" != "*DIR*" ]; then 
		Erreur 0 1 "L'option \"-n nom de l'ebook\" ne peut être activée avec le traitement de plusieurs elements sauf si nom ebook = *DIR*"
		getoptsErreur=0
	fi

	if [ ! -z "$nomPages" ] && [ "$nomPages" != "*DIR*" ]; then 
		Erreur 0 1 "L'option \"-p : nom des pages\" ne peut être activée avec le traitement de plusieurs elements sauf si nom ebook = *DIR*"
		getoptsErreur=0
	fi
fi

if [ $traiterContenu -eq 0 ]; then

	if [ ! -z "$nomEbook" ] && [ "$nomEbook" != "*DIR*" ]; then 
		Erreur 0 1 "L'option \"-n nom de l'ebook\" ne peut être activée avec l'option \" -g (traiter le contenu)\" sauf si nom ebook = *DIR*"
		getoptsErreur=0
	fi

	if [ ! -z "$nomPages" ] && [ "$nomPages" != "*DIR*" ]; then 
		Erreur 0 1 "L'option \"-p : nom des pages\" ne peut être activée avec l'option \" -g (traiter le contenu)\" sauf si nom ebook = *DIR*"
		getoptsErreur=0
	fi
fi


if [ $getoptsErreur -eq 0 ]; then
	Erreur 0 0 "Corriger les paramètres avant de relancer le script "
fi


######################################
# fichier script
######################################

#Import de option
Debug $debug 1 "Dossier principal du script : $mainpathscript"


# Creation des dossiers de travail
if [ ! -z "$dossierBackup" ]; then
	dossierBackup=$(realpath "$dossierBackup")
	if [ ! -d "$dossierBackup" ]; then
		mkdir -p "$dossierBackup" || Erreur 0 1 "Le dossier de backup n'est pas valid : $dossierBackup"
	fi
fi

if [ ! -z "$dossierNonImage" ]; then # TODO Comment déplacer si pas de dossier défini?????
	dossierNonImage=$(realpath "$dossierNonImage")
	if [ ! -d "$dossierNonImage" ]; then
		mkdir -p "$dossierNonImage" || Erreur 0 1 "Le dossier des fichiers non images n'est pas valid : $dossierNonImage"	
	fi
fi
			
if [ ! -z "$dossierFinal" ]; then
	dossierFinal=$(realpath "$dossierFinal")
	if [ ! -d "$dossierFinal" ]; then
		mkdir -p "$dossierFinal" || Erreur 0 1 "Le dossier final n'est pas valid : $dossierFinal"	
	fi
fi			

Debug $debug $confirmerDebug "Dossier backup : $dossierBackup \n Dossier non images : $dossierNonImage \n Dossier final : $dossierFinal"



function Dir2cbz ()
{
	local dossierATransformer="$1" 					
	local nomDossier=$(basename "$1")
	local nomEbook=""

	Debug $debug 1 "Fonction Dir2Cbz \n Dossier à convertir : $dossierATransformer \n Nom du fichier : $nomDossier"
	


	#Creation d'un backup avant traitement
	if [ $effectuerBackup -eq 0 ]; then
		Backup "$dossierATransformer" "$dossierBackup" || return 1
	fi
	
	#Nettoyage des fichier et dossier cache
	if [ $nettoyerCache -eq 0 ]; then
		CleanCache "$dossierATransformer" || return 2
	fi		
	
	#Suppression des fichiers qui ne sont pas des images
	if [ $imageSeulement -eq 0 ]; then
		RemoveNotImage_NEW "$dossierATransformer" "$dossierNonImage" || return 3
	fi	
	
	#Renommages des pages
	if [ ! -z "$nomPages" ]; then
		New_TEST_RenamePage "$dossierATransformer" "$nomPages" || return 4
	fi
	
	
	
	# generation du nom
	if [ "$nomEbook" == "*DIRN*" ]; then
		nomEbook=$(NettoyageNom "$nomDossier")

	elif [ -z "$nomEbook" ] || [ "$nomEbook" == '*DIR*' ]; then 
		nomEbook="$nomDossier"
	
	else
		nomEbook="$nomEbook"
	
	fi	
	
	# TODO : ajouter n°tome si collection avec dossier global

	nomEbook="$nomEbook.cbz"

	
#Debug 0 1 "OK jusque là -> PWD = $PWD"

	
	#creation du chemin
	if [ -z "$dossierFinal" ]; then	
		nomEbook="$PWD/$nomEbook"
	else	
		nomEbook="$dossierFinal/$nomEbook"
	fi	
	
#Debug 0 1 "KO jusque là -> PWD = $PWD"	
		
	#Debug $debug 0 "Chemin de l'ebook : $nomEbook"
	
		
#		return 0
	
CreateCbz "$dossierATransformer" "$nomEbook" $restructurerDossier || return 5	
	
if [ $effaceDossier -eq 0 ]; then
	rm -r "$dossierATransformer"
		
# TODO vérifier que dossier bien supprimé
fi
		
	return 0
}

nbtraitement=0
nberreur=0


declare -a erreurs

Scripterreur ()
{
	((nberreur++))
	erreurs[nberreur]="$1"
	
	return 0
}


for arg in "$@"; do

	Show  $verbose $debug "--------------  Traitement de $arg --------------"

	if [ $# -eq 0 ]; then
		dossierATraiter="$PWD"
		cd "$dossierATraiter/.."
		Dir2cbz "$dossierATraiter" || Scripterreur "$dossieraTraiter"
		((nbtraitement++))
		
	else
	
		if [ -f "$arg" ]; then
			Erreur 0 1 "$arg est un fichier ne peut pas être traité" && Scripterreur "$arg"
		fi

		if [ ! -d "$arg" ]; then
			Erreur 0 1 "Le dossier $arg est introuvable"  && Scripterreur "$arg"
		fi
		
		if [ -d "$arg" ]; then
			dossierATraiter=$(realpath "$arg")
			Show  $verbose $debug "Dossier à traiter : $dossierATraiter"

			if [ $traiterContenu -eq 0 ]; then

				cd "$dossierATraiter"
				find "$dossierATraiter" -mindepth 1 -maxdepth 1 -type d -print0 |
				while IFS= read -r -d '' dos; do
					Show  $verbose $debug "---------------------------------------------"
					echo " ---> $dos"
					Dir2cbz "$dos" #|| Scripterreur "$dossieraTraiter" # passer nom en paramètre pour renommer sur base collection????
					((nbtraitement++))
					
					echo "-----> $nbtraitement"
					
				done

			else
				cd "$dossierATraiter/.."
				Dir2cbz "$dossierATraiter" || Scripterreur "$dossieraTraiter"
				((nbtraitement++))
			
			fi

		fi
		
	fi
	
	Show  $verbose $debug "---------------------------------------------"

done

Show  $verbose $debug "********** RESUME ********** \n"

Show  $verbose $debug "Element sans erreur : " $nbtraitement
Show  $verbose $debug "Erreurs 			   : $nberreur"
Show  $verbose $debug "List des erreurs :"
Show  $verbose $debug $(printf '%s\n' "${erreurs[@]}")

exit 0

Watael · Le 19/05/2019, à 14:00

je ne suis pas convaincu par l'utilité de sort avec find.
à la rigueur, si tu dois écrire les noms des fichiers dans un fichier pour obtenir une liste ordonnée, mais pour déplacer/renommer (à moins de les renuméroter, bien sûr) des fichiers dans un système de fichiers qui ne les garder pas dans l'ordre

shift 2

Debug()
{
#...
   read ... </dev/tty

mainpathscript ne peut jamais valoir ., car . est un chemin relatif

CleanCache() : tu dois pouvoir ne faire qu'un seul find.
quelque chose comme ça

find  "$1" \( -type f -name "thumbs.db" -o -name ".DS_Store" \) -o -\( -type d -name _MACOSX \) -o empty -delete -print

avec -print, et pas -print0, parce que c'est illisible pour nous, humains, et que la sortie n'est pas réutilisée.

file|grep|wc -l

if [[ $(file "$fichier" =~ image ]]

NettoyageNom() : 7 sed ne devraient en faire qu'un.

for arg in "$@"; do test $#

il vaudrait mieux tester que des arguments sont passés au script avant d'entrer dans la boucle.

AGPArchitecture · Le 19/05/2019, à 18:50

@Watael

Merci beaucoup pour l'analyse et les commentaires sur l'ensemble du script. les remarques ont été intégrées.

Cependant certain choix de plusieures ligne à la place d'une seule était une meilleures lisibilité pour moi et mieux voir ce que je faisait (cleancache et le nettoyagenom par exemple)

-print0 n'est-il pas utilisé pour ne pas afficher le résultat du find?

le sort est bien utiliser pour renuméroter des fichiers en conserver l'ordre (numérotation de pages d'un ebook). Il est possible qu'il en reste quelques un d'inutiles suite à un copier/coller

je ne connaissait pas le raccourcissement : if [[ $(file "$fichier" =~ image ]]

bien vu pour la boucle, je faisait le traitement de $# dans la boucle

par contre j'ai toujours la question de :

qu'est ce que on entend par sortie et entrée standard
que signifie </dev/tty

Watael · Le 19/05/2019, à 19:30

Cependant certain choix de plusieures ligne à la place d'une seule était une meilleures lisibilité pour moi et mieux voir ce que je faisait (cleancache et le nettoyagenom par exemple)

c'est ce que je me suis dit, mais ça ralentit énormément le script, car la commande parcourt autant de fois le répertoire

-print0 n'est-il pas utilisé pour ne pas afficher le résultat du find?

non, c'est pour afficher la liste des fichiers séparés par un caractère NULL

je ne connaissait pas le raccourcissement : if [[ $(file "$fichier" =~ image ]]

attention, j'ai oublié une parenthèse :

if [[ $(file -i "$image") =~ image ]]

qu'est ce que on entend par sortie et entrée standard

toutes les commandes se voient attribuées trois "canaux" de communications :
une entrée standard (stdin), ce que lit une commande (par un pipe, par exemple, qu'il ne faut pas confondre avec les arguments)
une sortie standard (stdout), et une sortie d'erreur standard (stderr), qui sont affichées dans le terminal, mais ne passent pas par le même canal, pour permettre de les afficher, ou pas.

que signifie </dev/tty

c'est une redirection (<) de l'entrée standard du terminal courant.
donc, ce qui est tapé dans le terminal sera lu par la commande vers laquelle pointe la redirection.

est-ce clair ?

AGPArchitecture · Le 21/05/2019, à 18:46

Merci Watael

je mets en résolu

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 18/05/2019, à 15:46

[RESOLU] comportement incompréhensible sur script

#2 Le 18/05/2019, à 16:41

Re : [RESOLU] comportement incompréhensible sur script

#3 Le 18/05/2019, à 17:06

Re : [RESOLU] comportement incompréhensible sur script

#4 Le 18/05/2019, à 17:47

Re : [RESOLU] comportement incompréhensible sur script

#5 Le 18/05/2019, à 18:54

Re : [RESOLU] comportement incompréhensible sur script

#6 Le 18/05/2019, à 19:13

Re : [RESOLU] comportement incompréhensible sur script

#7 Le 19/05/2019, à 12:11

Re : [RESOLU] comportement incompréhensible sur script

#8 Le 19/05/2019, à 14:00

Re : [RESOLU] comportement incompréhensible sur script

#9 Le 19/05/2019, à 18:50

Re : [RESOLU] comportement incompréhensible sur script

#10 Le 19/05/2019, à 19:30

Re : [RESOLU] comportement incompréhensible sur script

#11 Le 21/05/2019, à 18:46

Re : [RESOLU] comportement incompréhensible sur script

Pied de page des forums