Contenu | Rechercher | Menus

Annonce

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 29/08/2012, à 21:48

thurston

[RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bonjour

Dans le but de naviguer dans un lecteur mp3, et en ayant beaucoup d'artistes sous un même genre, je cherche à compacter ce répertoire en suivant ce process (en bash si possible):
n_max_folder: nombre de folder à partir du moment où le script compacte, disons 12 pour fixer les idées (après, il faut scroller + que 6 fois en passant dans un sens ou dans un autre pour arriver à l'artiste souhaité, résultat de même nature à la navigation avec le répertoire compacté, ou du moins plus rapide.

Si un répertoire contient plus que n_max_folder, alors ceux ci sont regroupés automatiquement sous ces sous répertoires alors créés automatiquement
(A-F)
(G-L)
(M-R)
(S-Z)
(0-9)
je considère ainsi que tous les noms de répertoires commencent soit par un chiffre soit par une lettre classique de l'alphabet. (hypothèse à vérifier, si pas le cas, je mets ça das le (0-9), en fin de boucle else qui prend tout ce qui n'est pas alphabétique.
J'ai bien bricolé un script horrible, mais je m'emmêle les pinceaux car quand je modifie la structure des dossier déjà lus, le script ne s'y retrouve plus (récursivité souhaitée). Je peux faire niveau par niveau (en connaissant la profondeur initiale, et en déroulant couche par couche) mais le script devient vraiment horrible.
Une bonne âme pour me donner un coup de main? J'ai l'impression qu'avec les bonnes boucles (for ou while) le résultat peut etre très efficace, à condition de commencer par l plus bas niveau peut etre...
D'avance merci
A+
T

exemple
si j'ai un folder contenant des folders nommés par une lettre chacun différente, je m'attends à trouver ceci en fin de script (exemple sans récursivité ici pour simplifier l'affichage)

ls .
awhatever  ewhatever  iwhatever  mwhatever  qwhatever  uwhatever
bwhatever  fwhatever  jwhatever  nwhatever  rwhatever  vwhatever
cwhatever  gwhatever  kwhatever  owhatever  swhatever  wwhatever
dwhatever  hwhatever  lwhatever  pwhatever  twhatever

après script

tree .
.
├── (A-F)
│   ├── awhatever
│   ├── bwhatever
│   ├── cwhatever
│   ├── dwhatever
│   ├── ewhatever
│   └── fwhatever
├── (G-L)
│   ├── gwhatever
│   ├── hwhatever
│   ├── iwhatever
│   ├── jwhatever
│   ├── kwhatever
│   └── lwhatever
├── (M-R)
│   ├── mwhatever
│   ├── nwhatever
│   ├── owhatever
│   ├── pwhatever
│   ├── qwhatever
│   └── rwhatever
└── (S-Z)
    ├── swhatever
    ├── twhatever
    ├── uwhatever
    ├── vwhatever
    └── wwhatever

Dernière modification par thurston (Le 01/09/2012, à 20:09)

Hors ligne

#2 Le 29/08/2012, à 22:47

pingouinux

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bonsoir,
Peux-tu donner un exemple avec 2 ou 3 niveaux ?

Hors ligne

#3 Le 29/08/2012, à 22:57

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Voici, je pense que c'est simple et efficace :

#!/bin/bash

maxfiles=6

# on crèe un tableau
files=( * )

# on itère sur les fichiers
for ((i=0; i<${#files[@]}; i++)); do
    curfile="${files[i]}"

    # on test si il reste un reste à la division de l'index/maxfiles (modulo) : multiple de maxfiles
    if ! ((i % maxfiles)); then
        lastone="${files[i+maxfiles-1]}"
        c=0
        until [[ -e "$lastone" ]]; do
            lastone="${files[i+maxfiles-1-c++]}"
        done
        curdir="${curfile:0:1}-${lastone:0:1}"
        mkdir -p "$curdir"
    fi

    mv "$curfile" "$curdir"
done

Resultat :

$ tree
.
├── a-f
│   ├── awhatever
│   ├── bwhatever
│   ├── cwhatever
│   ├── dwhatever
│   ├── ewhatever
│   └── fwhatever
├── g-l
│   ├── gwhatever
│   ├── hwhatever
│   ├── iwhatever
│   ├── jwhatever
│   ├── kwhatever
│   └── lwhatever
├── m-r
│   ├── mwhatever
│   ├── nwhatever
│   ├── owhatever
│   ├── pwhatever
│   ├── qwhatever
│   └── rwhatever
└── s-w
    ├── swhatever
    ├── twhatever
    ├── uwhatever
    ├── vwhatever
    └── wwhatever

Dernière modification par sputnick (Le 29/08/2012, à 22:58)


On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#4 Le 29/08/2012, à 23:29

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

@ sputnick
Merci pour le boulot (j'ai malheureusement pas le niveau pour comprendre le fonctionnement en profondeur) mais ca a l'air de coller avec ce que j'avais en tete, mais j'ai du mal à utiliser le script. je veux dire, je vais utiliser la fonction dans un script en appelant la fonction proposée et en lui passant en argument le repertoire racine, ainsi que la taille de limite
Peux tu stp encapsuler ta proposition comme suit (j'y arrive pas ;-(,  ce qui m'intéresse c'est les ... et surtout où placer correctement le $1!!!

function compact_folder()
{
#$1= repertoire à traiter
#$2= taille limite pour traitement
....
}

@ pingouinux

ca ressemblerait à ca pour le résultat appliqué avec récursivité sur un 2 niveaux (dans mon cas ce serait:
genre
- artist1
- artist2
- artist3
   ....
- artist14
  - album1
  - album2
    ...
   - album15
- artist24

et par exemple l'artiste 14 a à son actif 15 albums

Ainsi, les artistes du genre doivent etre compactés, et l'artiste 14 (si le seul a être si prolifique) doit etre compacté sur ses albums.
En espérant etre clair.

Le résultat serait alors du style

tree .
├── (A-F)
│   ├── awhatever
│   ├── bwhatever
│   ├── cwhatever
│   ├── dwhatever
│   ├── dwhatever1
│   ├── ewhatever
│   │   ├── (A-F)
│   │   │   ├── awhatever
│   │   │   ├── bwhatever
│   │   │   ├── cwhatever
│   │   │   ├── dwhatever
│   │   │   ├── ewhatever
│   │   │   └── fwhatever
│   │   ├── (G-L)
│   │   │   ├── gwhatever
│   │   │   ├── hwhatever
│   │   │   ├── hwhatever1
│   │   │   ├── iwhatever
│   │   │   ├── jwhatever
│   │   │   ├── kwhatever
│   │   │   └── lwhatever
│   │   ├── (M-R)
│   │   │   ├── mwhatever
│   │   │   ├── nwhatever
│   │   │   ├── owhatever
│   │   │   ├── pwhatever
│   │   │   ├── qwhatever
│   │   │   └── rwhatever
│   │   └── (S-Z)
│   │       ├── swhatever
│   │       │   ├── (A-F)
│   │       │   │   ├── awhatever
│   │       │   │   ├── bwhatever
│   │       │   │   ├── cwhatever
│   │       │   │   ├── dwhatever
│   │       │   │   ├── ewhatever
│   │       │   │   └── fwhatever
│   │       │   ├── (G-L)
│   │       │   │   ├── gwhatever
│   │       │   │   ├── hwhatever
│   │       │   │   ├── iwhatever
│   │       │   │   ├── jwhatever
│   │       │   │   ├── kwhatever
│   │       │   │   └── lwhatever
│   │       │   ├── (M-R)
│   │       │   │   ├── mwhatever
│   │       │   │   ├── nwhatever
│   │       │   │   ├── owhatever
│   │       │   │   ├── pwhatever
│   │       │   │   ├── qwhatever
│   │       │   │   └── rwhatever
│   │       │   └── (S-Z)
│   │       │       ├── swhatever
│   │       │       ├── twhatever
│   │       │       ├── uwhatever
│   │       │       ├── vwhatever
│   │       │       └── wwhatever
│   │       ├── twhatever
│   │       ├── uwhatever
│   │       ├── vwhatever
│   │       └── wwhatever
│   └── fwhatever
├── (G-L)
│   ├── gwhatever
│   ├── hwhatever
│   ├── iwhatever
│   ├── jwhatever
│   ├── kwhatever
│   └── lwhatever
├── (M-R)
│   ├── mwhatever
│   ├── nwhatever
│   ├── owhatever
│   ├── pwhatever
│   ├── qwhatever
│   └── rwhatever
└── (S-Z)
    ├── swhatever
    ├── twhatever
    ├── uwhatever
    ├── vwhatever
    └── wwhatever

Hors ligne

#5 Le 29/08/2012, à 23:34

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Simple :

compact_folder() {
    cd "$1"
    maxfiles=$2

    # on crèe un tableau
    files=( * )

    # on itère sur les fichiers
    for ((i=0; i<${#files[@]}; i++)); do
        curfile="${files[i]}"

        # on test si il reste un reste à la division de l'index/maxfiles (modulo) : multiple de maxfiles
        if ! ((i % maxfiles)); then
            lastone="${files[i+maxfiles-1]}"
            c=0
            until [[ -e "$lastone" ]]; do
                lastone="${files[i+maxfiles-1-c++]}"
            done
            curdir="${curfile:0:1}-${lastone:0:1}"
            mkdir -p "$curdir"
        fi

        mv "$curfile" "$curdir"
    done
}

Dit ce que tu comprends pas, je t'explique, c'est assez simple quand meme et court en plus...

Dernière modification par sputnick (Le 29/08/2012, à 23:35)


On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#6 Le 29/08/2012, à 23:46

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

@ sputnick

merci, j'ai pu tester, mais j'ai pas l'impression que le script gère la récursivité?
Je veux dire sur un niveau ca marche impec. Mais si on copie la structure de niveau -1 dans un répertoire quelconque de ce niveau (donc on a une espèce de copier coller de structure en niveau -2, les 2 devraient etre traités et afficher le même résultat non?, à chaque fois à leur niveau respectif.
A+ (au fait je vais me coucher, boulot demain ...zzzz)
T

Hors ligne

#7 Le 30/08/2012, à 11:30

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

@ sputnick
J'ai testé ton script que je trouve puissant (rapide et efficace). Par contre, il ne fait pas ce que je souhaitais initialement. Désolé surement pas clair mon énoncé.
Ton script saucissone un répertoire de facon à ce que chaque répertoire contienne au plus 6 répertoires, en accomodant le naming des répertoires créés en fonction du besoin.
Je souhaitais plus transformé le répertoire avec trop de sous répertoires en créant des sous répertoires (6) ayant finalement toujours le même nom A-F....et existant si besoin et contenant x sous répertoire à la demande. En sachant que la moulinette s'appliquait également aux albums de l'artiste si besoin.

Ainsi le résutat pouvait etre:
(A-F)
- Artiste1
- Artiste2
- Artiste3
- Artiste4
- Artiste5
- Artiste6
(G-L)
- Gartiste1
- Lartiste1
(M-...

Merci d'avance si toujours intéressé
A+
T

Hors ligne

#8 Le 30/08/2012, à 14:06

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Il te suffit donc d'adapter mon script pour faire ce que tu veut. ça devrais être une bonne base.


On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#9 Le 30/08/2012, à 17:48

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Oui j'ai bien conscience que la routine est optimisée et que un bon morceau (le plus délicat) est dispo, mais pas le niveau pour reprendre ca. Ce que j'avais bricolé, c'était avec des find, des grep et des comparaisons de la 1ere lettre du repertoire pour le ranger dans le bon sub à créer. Pas très élevé comme niveau mais c'est le mien hélàs...
Merci A+
T

Hors ligne

#10 Le 30/08/2012, à 19:00

pingouinux

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bonjour,
Ce n'est pas exactement ce qui est demandé (je n'ai pas tout compris), mais je peux te proposer ceci :

$ cat dico.sh
#!/bin/bash

cd "$1"
n_rep_max=$2

creation_rep() (
liste=("$@")
n_tot=${#liste[@]}
n_elem_par_rep=0
((n_elem_par_rep=(n_tot+n_rep_max-1)/n_rep_max))
if ((n_elem_par_rep<n_rep_max))
then
n_rep_max1=$n_elem_par_rep
((n_elem_par_rep=(n_tot+n_rep_max1-1)/n_rep_max1))
fi
for ((k=0;k<n_tot;k+=n_elem_par_rep))
do
   deb_nom=${liste[k]}
   k1=$((k+n_elem_par_rep-1))
   ((k1>=n_tot)) && k1=$((n_tot-1))
   fin_nom=${liste[k1]}
   nom_rep="$deb_nom-$fin_nom"
   mkdir "$nom_rep"
   mv  "${liste[@]:k:n_elem_par_rep}" "$nom_rep"
   cd "$nom_rep"
   ((k1-k+1>n_rep_max)) && creation_rep "${liste[@]:k:n_elem_par_rep}"
   cd ..
done
)

liste=( $(sort <<<"*") )
creation_rep "${liste[@]}"

Je l'ai testé comme ceci :

$ cd /tmp/tst; rm -r *; touch {a..e}{a..f}fic; /tmp/dico.sh /tmp/tst 3 
$ tree .
.
├── aafic-bdfic
│   ├── aafic-adfic
│   │   ├── aafic-abfic
│   │   │   ├── aafic
│   │   │   └── abfic
│   │   └── acfic-adfic
│   │       ├── acfic
│   │       └── adfic
│   ├── aefic-bbfic
│   │   ├── aefic-affic
│   │   │   ├── aefic
│   │   │   └── affic
│   │   └── bafic-bbfic
│   │       ├── bafic
│   │       └── bbfic
│   └── bcfic-bdfic
│       ├── bcfic
│       └── bdfic
├── befic-dbfic
│   ├── befic-cbfic
│   │   ├── befic-bffic
│   │   │   ├── befic
│   │   │   └── bffic
│   │   └── cafic-cbfic
│   │       ├── cafic
│   │       └── cbfic
│   ├── ccfic-cffic
│   │   ├── ccfic-cdfic
│   │   │   ├── ccfic
│   │   │   └── cdfic
│   │   └── cefic-cffic
│   │       ├── cefic
│   │       └── cffic
│   └── dafic-dbfic
│       ├── dafic
│       └── dbfic
└── dcfic-effic
    ├── dcfic-dffic
    │   ├── dcfic-ddfic
    │   │   ├── dcfic
    │   │   └── ddfic
    │   └── defic-dffic
    │       ├── defic
    │       └── dffic
    ├── eafic-edfic
    │   ├── eafic-ebfic
    │   │   ├── eafic
    │   │   └── ebfic
    │   └── ecfic-edfic
    │       ├── ecfic
    │       └── edfic
    └── eefic-effic
        ├── eefic
        └── effic

24 directories, 30 files

Dernière modification par pingouinux (Le 30/08/2012, à 19:41)

Hors ligne

#11 Le 30/08/2012, à 19:07

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

bon merci à tous de tenter de répondre à un script pas trop bien décrit ... désolé.
Vous allez tous flipper un grand coup, mais tant pis. Je vous joins mon horreur...qui marche je crois, et qui ...est ignoble aussi je le sais.
Ca eclaircira sans doute sur les envies.
A+
Merci
T

#!/bin/bash

function folder_optimization()
{
# $1: folder to re-arrange
# $2: folder limit 12
# for i in a b c d e f g h i j k l m n o p q r s t u v w; do mkdir "$i"whatever ; done
#
master_folder="$1"
folder_limit=$2
max_initial_depth=`find "$master_folder" -printf '%d\n' | sort -n  | tail -1`

depth=$max_initial_depth
echo $depth
while [ $(( depth+1 )) -gt 0 ]
do
   for folder in `find "$master_folder" -mindepth $depth -maxdepth $depth -type d ! -name ".*" | sort `
   do
      if [ `find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | wc -l` -ge $folder_limit ]  #1
      then
         for subfolder in `find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | sort `
         do
            foldername="`basename "$subfolder"`"
            letter1=`echo ${foldername::1}`
            if `echo "a b c d e f" | grep -i "${letter1}" 1>/dev/null 2>&1`
            then
               if [ ! -e "$folder/(A-F)" ]; then mkdir -p "$folder"/\(A-F\) ; fi
               echo "$folder/(A-F)"
               mv "$subfolder" "$folder/(A-F)"
            else
               if `echo "g h i j k l" | grep -i "${letter1}" 1>/dev/null 2>&1`
               then
                  if [ ! -e "$folder/(G-L)" ]; then mkdir -p "$folder"/\(G-L\) ; fi
                  echo "$folder/(G-L)"
                  mv "$subfolder" "$folder/(G-L)/$sub_folder"
               else
                  if `echo "m n o p q r" | grep -i "${letter1}" 1>/dev/null 2>&1`
                  then
                     if [ ! -e "$folder/(M-R)" ]; then mkdir -p "$folder"/\(M-R\) ; fi
                     echo "$folder/(M-R)"
                     mv "$subfolder" "$folder/(M-R)/$sub_folder"
                  else
                     if `echo "s t u v w x y z" | grep -i "${letter1}" 1>/dev/null 2>&1`
                     then
                       if [ ! -e "$folder/(S-Z)" ]; then mkdir -p "$folder"/\(S-Z\) ; fi
                       echo "$folder/(S-Z)"
                       mv "$subfolder" "$folder/(S-Z)/$sub_folder"
                     else
                       if [ ! -e "$folder/(0-9)" ]; then mkdir -p "$folder"/\(0-9\) ; fi
                       echo "$folder/(0-9)"
                       mv "$subfolder" "$folder/(0-9)/$sub_folder"
                     fi
                  fi
               fi
            fi
         done
      fi
   done
   depth=$(( depth-1 ))
done
}

folder_optimization "$1" $2
exit

Hors ligne

#12 Le 30/08/2012, à 19:31

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bon ce qui est certain, je commence à m'en rendre compte, c'est que je n'optimise pas du tout le rangement. (ce que je pense vous tentez de faire). En effet, si on a plein d'artiste entre A et F, et peu après, l'optimisation est plus que limitée. Le script de sputnick était en cela plus intéressant, et finalement la solution ultime était un découpage auto-adaptatif qui minimise le nombre de sous folder dans chaque folder quelque soit le niveau...

Le 1er niveau peut etre compacté en remplissant les folders comme suit:
A-F(3) + G-L(3) + M-Z(2)
Avec 3 folder de 3 folder visés

alors qu'un autre niveau dans l'arborescence serait lui découpé comme suit (si plus nombreux)
A-D(6) + E-G(7) + H-K(7) + L-N(7) + O-R(7) + S-U(7) + V-Z(6)
Avec 7 folder de 7 folder visés

Est ce que cela aurait un sens??? Désolé, je m'arrete un peu pour redéfinir le besoin si vous voulez participer à la reflexion je prends vos commentaires.
L'idée est de parvenir au bon folder en multi niveau en un minimum de manipulation (1 manipulation = deplacement dans un folder (même niveau ou niveau du dessous).
Je continue à réfléchir sur l'optimisation et la redéfinition.
A+
T

EDIT: après des tests sur chacun des scripts, je me demande si la solution la plus proche ne serait pas dans ce gout là et alors pas mal optimisée:
En utilisant le script de sputnick et en l'appliquant à chaque niveau de folder en commencant par le niveau le plus bas:
compact "folder" "fction de(n.folder)" (je cherche la fction, peut etre proche de racine carrée de n.folder intuitivement, à partir d'un certainnombre (6))
Je m'explique:
- si j'ai 06 folders, la fonction retourne 6 (en rapport avec le script de sputnick, et donc pas de compactage car pas nécessaire)
- si j'ai 09 folders, la fonction retourne 3 je compacte à 3 folders de 3
- si j'ai 16 folders, la fonction retourne 4 je compacte à 4 folder max dans chaque folder, soit 4 folders de 4, pas mal

le gain est le suivant dans le cas de 25 repertoires sous la racine au même niveau:
25 à plat
=> 2ème repertoire selectionné en 1 clic bas
=> 13ème et plus lointain repertoire selectionné en 12 clics bas (au delà on reverse les clics pour redémarrer en ordre contraire
compactage à 5 (donc 5 5 5 5 5)
=> 2ème repertoire selectionné en 2 clics (1 lateral + 1 clic bas) = on perd un clic
=> 12ème repertoire selectionné (+ lointain) en  5 clics (2 bas + 3 lateral) bas = 7 clics de gagné!!!

bon c'est peut etre rien pour vous, mais je suis un fan de Post-Rock et j'ai environ 200 groupes sous ce genre...soit 20 clics contre 100 au pire ou au mieux selon l'angle...

Dernière modification par thurston (Le 30/08/2012, à 21:40)

Hors ligne

#13 Le 30/08/2012, à 22:15

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bon j'essaie ca mais ca plante.
Ca reprend l'idée développée plus haut en intégrant le script cité. Surement pas élégant dans l'écriture, mais je voudrais bien voir le résultat de l'idée.
Attention le script plante...je crois que c'est parce que compact_folder n'aime pas ne rien avoir à manger.
A+
T

#!/bin/bash

compact_folder() {
    test=`ls "$1"`
    if [ "$test" = "" ]; then return; fi
    cd "$1"
    maxfiles=$2

    # on crèe un tableau
    files=( * )

    # on itère sur les fichiers
    for ((i=0; i<${#files[@]}; i++)); do
        curfile="${files[i]}"

        # on test si il reste un reste à la division de l'index/maxfiles (modulo) : multiple de maxfiles
        if ! ((i % maxfiles)); then
            lastone="${files[i+maxfiles-1]}"
            c=0
            until [[ -e "$lastone" ]]; do
                lastone="${files[i+maxfiles-1-c++]}"
            done
            curdir="${curfile:0:1}-${lastone:0:1}"
            mkdir -p "$curdir"
        fi

        mv "$curfile" "$curdir"
    done
}

function folder_optimization()
{
# $1: folder to re-arrange
#
master_folder="$1"
max_initial_depth=`find "$master_folder" -printf '%d\n' | sort -n  | tail -1`
echo $max_initial_depth
depth=$(bc <<<"$max_initial_depth-1") #faudrait pas que je commence à $max_initial_depth-1 ?

while [ $(( depth+1 )) -gt 0 ] #je pars du plus profond en remontant jusqu'au dernier niveau
do
   for folder in `find "$master_folder" -mindepth $depth -maxdepth $depth -type d ! -name ".*" | sort ` # je liste les répertoires ayant des sous répertoires
   do
      nb_folder=`find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | wc -l` # je compte son nombre de sous repertoires
      if [ $nb_folder -lt 6 ]; then param=6; else param=$(bc <<<"sqrt($nb_folder)");fi #j'applique le parametre en fonction
      compact_folder "$folder" $param #et je compacte en utilisant la fonction
   done
   depth=$(( depth-1 )) # je remonte d'un cran
done
}

folder_optimization "$1"
exit

Dernière modification par thurston (Le 30/08/2012, à 22:41)

Hors ligne

#14 Le 30/08/2012, à 22:29

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Attention aux espaces dans les noms de fichiers, c'est pour ça qu'on ne doit pas faire de   

for folder in `find "$master_folder"

mais plutôt

while read folder; do echo "$folder"; done < < find "$master_folder"

On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#15 Le 30/08/2012, à 22:43

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Ben en fait je suis juste à l'aise avec les boucles for, les while pas encore...
J'ai modifié le script qui plante ci dessus (plante un peu moins avec un test sur ta fonction avant de l'executer).
Ca process bien le plus bas niveau mais après ca plante...

EDIT:j'essaye bien en ce moment avec ceci mais

while read folder; do echo "$folder"; done <<< `find "$master_folder"`

mais ca lit tout d'un coup... et pas un par un, donc traitement impossible
pas plutot comme ca,

while read folder; do echo "$folder"; done <<< "`find "$1"`"

du coup le script (qui plante tjrs donne)...et je vais .....zzzz, car plus de jus. Merci à tous!!

#!/bin/bash

compact_folder() {
    test=`ls "$1"`
    if [ "$test" = "" ]; then return; fi
    cd "$1"
    maxfiles=$2

    # on crèe un tableau
    files=( * )

    # on itère sur les fichiers
    for ((i=0; i<${#files[@]}; i++)); do
        curfile="${files[i]}"

        # on test si il reste un reste à la division de l'index/maxfiles (modulo) : multiple de maxfiles
        if ! ((i % maxfiles)); then
            lastone="${files[i+maxfiles-1]}"
            c=0
            until [[ -e "$lastone" ]]; do
                lastone="${files[i+maxfiles-1-c++]}"
            done
            curdir="${curfile:0:1}-${lastone:0:1}"
            mkdir -p "$curdir"
        fi

        mv "$curfile" "$curdir"
    done
}

function folder_read()
{
while read folder; do echo "$folder"; done < <(find "$1")
}

function folder_optimization()
{
# $1: folder to re-arrange
#
master_folder="$1"
max_initial_depth=`find "$master_folder" -printf '%d\n' | sort -n  | tail -1`
echo $max_initial_depth
depth=$(bc <<<"$max_initial_depth") #faudrait pas que je commence à $max_initial_depth-1 ?

while [ $(( depth+1 )) -gt 0 ] #je pars du plus profond en remontant jusqu'au dernier niveau
do
   while read folder
   do
      nb_folder=`find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | wc -l` # je compte son nombre de sous repertoires
      if [ $nb_folder -lt 6 ]; then param=6; else param=$(bc <<<"sqrt($nb_folder)");fi #j'applique le parametre en fonction
      compact_folder "$folder" $param #et je compacte en utilisant la fonction
   done < <(find "$master_folder" -mindepth $depth -maxdepth $depth -type d ! -name ".*" | sort -n) # je liste les répertoires ayant des sous répertoires
   depth=$(( depth-1 )) # je remonte d'un cran
done
}

folder_optimization "$1"
#folder_read "$1"
exit

Dernière modification par thurston (Le 30/08/2012, à 23:25)

Hors ligne

#16 Le 30/08/2012, à 23:19

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Oups, désolé, il s'agissait en fait de :

while read folder; do echo "$folder"; done < <(find "$master_folder")

( De tête )

Remplace évidement

echo "$folder"

par ton code sur la variable $folder...


On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#17 Le 30/08/2012, à 23:25

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

ok ca marche mieux pour cette commande merci
ca solutionne pas le script qui ne monte pas de niveau...ne traite que le niveau le plus bas et renvoie des erreurs après.
faut que j'aille zzzzz désolé et merci.
Ma dernière version de soft est juste au dessus.

Dernière modification par thurston (Le 30/08/2012, à 23:27)

Hors ligne

#18 Le 31/08/2012, à 00:37

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Dire ya des erreurs sans rien préciser est stérile wink
Copie colle nous ces erreurs.
Step by step.


On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#19 Le 31/08/2012, à 07:24

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

vrai, je pensais que le script était assez simple pour y dénicher l'erreur rapidement.
Du coup, je poste ici une creation d'arbo type à gérer:

mkdir -p /tmp/post-rock/caspian/{a..e}_album;mkdir -p /tmp/post-rock/caspian/{m..z}_album;mkdir -p /tmp/post-rock/damascus/{a..m}_album;mkdir -p /tmp/post-rock/damascus/{t..z}_album;mkdir -p /tmp/post-rock/vasudeva/{a..e}{a..m}_album;mkdir -p /tmp/post-rock/vasudeva/{m..z}_album;mkdir -p /tmp/post-rock/tides/{a..f}_album;mkdir -p /tmp/post-rock/tides/{p..w}_album;mkdir -p /tmp/post-rock/daturah/{a..c}{f..m}_album;mkdir -p /tmp/post-rock/daturah/{e..k}_album;mkdir -p /tmp/post-rock/daturah/{p..z}_album;mkdir -p /tmp/post-rock/exxasens/{a..g}_album;mkdir -p /tmp/post-rock/exxasens/{p..z}_album;mkdir -p /tmp/post-rock/firespoken/{a..g}_album;mkdir -p /tmp/post-rock/firespoken/{t..z}_album;mkdir -p /tmp/post-rock/glorie/{f..m}_album;mkdir -p /tmp/post-rock/glorie/{t..z}_album;mkdir -p /tmp/post-rock/hadoken/{c..f}_album;mkdir -p /tmp/post-rock/hadoken/{p..t}_album;

le résultat du script est pas si mal puisqu'une fois traité, on a ca...faut que je retrouve les erreurs que j'avais hier soir, tiens...Je continue mes tests et je reposterai si je retrouve les dysfonctionnements notés.
A+
Merci

tree /tmp/post-rock/
/tmp/post-rock/
├── c-d
│   ├── caspian
│   │   ├── a-d
│   │   │   ├── a_album
│   │   │   ├── b_album
│   │   │   ├── c_album
│   │   │   └── d_album
│   │   ├── e-o
│   │   │   ├── e_album
│   │   │   ├── m_album
│   │   │   ├── n_album
│   │   │   └── o_album
│   │   ├── p-s
│   │   │   ├── p_album
│   │   │   ├── q_album
│   │   │   ├── r_album
│   │   │   └── s_album
│   │   ├── t-w
│   │   │   ├── t_album
│   │   │   ├── u_album
│   │   │   ├── v_album
│   │   │   └── w_album
│   │   └── x-z
│   │       ├── x_album
│   │       ├── y_album
│   │       └── z_album
│   ├── damascus
│   │   ├── a-d
│   │   │   ├── a_album
│   │   │   ├── b_album
│   │   │   ├── c_album
│   │   │   └── d_album
│   │   ├── e-h
│   │   │   ├── e_album
│   │   │   ├── f_album
│   │   │   ├── g_album
│   │   │   └── h_album
│   │   ├── i-l
│   │   │   ├── i_album
│   │   │   ├── j_album
│   │   │   ├── k_album
│   │   │   └── l_album
│   │   ├── m-v
│   │   │   ├── m_album
│   │   │   ├── t_album
│   │   │   ├── u_album
│   │   │   └── v_album
│   │   └── w-z
│   │       ├── w_album
│   │       ├── x_album
│   │       ├── y_album
│   │       └── z_album
│   └── daturah
│       ├── a-a
│       │   ├── af_album
│       │   ├── ag_album
│       │   ├── ah_album
│       │   ├── ai_album
│       │   ├── aj_album
│       │   └── ak_album
│       ├── a-b
│       │   ├── al_album
│       │   ├── am_album
│       │   ├── bf_album
│       │   ├── bg_album
│       │   ├── bh_album
│       │   └── bi_album
│       ├── b-c
│       │   ├── bj_album
│       │   ├── bk_album
│       │   ├── bl_album
│       │   ├── bm_album
│       │   ├── cf_album
│       │   └── cg_album
│       ├── c-c
│       │   ├── ch_album
│       │   ├── ci_album
│       │   ├── cj_album
│       │   ├── ck_album
│       │   ├── cl_album
│       │   └── cm_album
│       ├── e-j
│       │   ├── e_album
│       │   ├── f_album
│       │   ├── g_album
│       │   ├── h_album
│       │   ├── i_album
│       │   └── j_album
│       ├── k-t
│       │   ├── k_album
│       │   ├── p_album
│       │   ├── q_album
│       │   ├── r_album
│       │   ├── s_album
│       │   └── t_album
│       └── u-z
│           ├── u_album
│           ├── v_album
│           ├── w_album
│           ├── x_album
│           ├── y_album
│           └── z_album
├── e-g
│   ├── exxasens
│   │   ├── a-d
│   │   │   ├── a_album
│   │   │   ├── b_album
│   │   │   ├── c_album
│   │   │   └── d_album
│   │   ├── e-p
│   │   │   ├── e_album
│   │   │   ├── f_album
│   │   │   ├── g_album
│   │   │   └── p_album
│   │   ├── q-t
│   │   │   ├── q_album
│   │   │   ├── r_album
│   │   │   ├── s_album
│   │   │   └── t_album
│   │   ├── u-x
│   │   │   ├── u_album
│   │   │   ├── v_album
│   │   │   ├── w_album
│   │   │   └── x_album
│   │   └── y-z
│   │       ├── y_album
│   │       └── z_album
│   ├── firespoken
│   │   ├── a-c
│   │   │   ├── a_album
│   │   │   ├── b_album
│   │   │   └── c_album
│   │   ├── d-f
│   │   │   ├── d_album
│   │   │   ├── e_album
│   │   │   └── f_album
│   │   ├── g-u
│   │   │   ├── g_album
│   │   │   ├── t_album
│   │   │   └── u_album
│   │   ├── v-x
│   │   │   ├── v_album
│   │   │   ├── w_album
│   │   │   └── x_album
│   │   └── y-z
│   │       ├── y_album
│   │       └── z_album
│   └── glorie
│       ├── f-h
│       │   ├── f_album
│       │   ├── g_album
│       │   └── h_album
│       ├── i-k
│       │   ├── i_album
│       │   ├── j_album
│       │   └── k_album
│       ├── l-t
│       │   ├── l_album
│       │   ├── m_album
│       │   └── t_album
│       ├── u-w
│       │   ├── u_album
│       │   ├── v_album
│       │   └── w_album
│       └── x-z
│           ├── x_album
│           ├── y_album
│           └── z_album
└── h-v
    ├── hadoken
    │   ├── c-e
    │   │   ├── c_album
    │   │   ├── d_album
    │   │   └── e_album
    │   ├── f-q
    │   │   ├── f_album
    │   │   ├── p_album
    │   │   └── q_album
    │   └── r-t
    │       ├── r_album
    │       ├── s_album
    │       └── t_album
    ├── tides
    │   ├── a-c
    │   │   ├── a_album
    │   │   ├── b_album
    │   │   └── c_album
    │   ├── d-f
    │   │   ├── d_album
    │   │   ├── e_album
    │   │   └── f_album
    │   ├── p-r
    │   │   ├── p_album
    │   │   ├── q_album
    │   │   └── r_album
    │   ├── s-u
    │   │   ├── s_album
    │   │   ├── t_album
    │   │   └── u_album
    │   └── v-w
    │       ├── v_album
    │       └── w_album
    └── vasudeva
        ├── a-a
        │   ├── aa_album
        │   ├── ab_album
        │   ├── ac_album
        │   ├── ad_album
        │   ├── ae_album
        │   ├── af_album
        │   ├── ag_album
        │   └── ah_album
        ├── a-b
        │   ├── ai_album
        │   ├── aj_album
        │   ├── ak_album
        │   ├── al_album
        │   ├── am_album
        │   ├── ba_album
        │   ├── bb_album
        │   └── bc_album
        ├── b-b
        │   ├── bd_album
        │   ├── be_album
        │   ├── bf_album
        │   ├── bg_album
        │   ├── bh_album
        │   ├── bi_album
        │   ├── bj_album
        │   └── bk_album
        ├── b-c
        │   ├── bl_album
        │   ├── bm_album
        │   ├── ca_album
        │   ├── cb_album
        │   ├── cc_album
        │   ├── cd_album
        │   ├── ce_album
        │   └── cf_album
        ├── c-d
        │   ├── cg_album
        │   ├── ch_album
        │   ├── ci_album
        │   ├── cj_album
        │   ├── ck_album
        │   ├── cl_album
        │   ├── cm_album
        │   └── da_album
        ├── d-d
        │   ├── db_album
        │   ├── dc_album
        │   ├── dd_album
        │   ├── de_album
        │   ├── df_album
        │   ├── dg_album
        │   ├── dh_album
        │   └── di_album
        ├── d-e
        │   ├── dj_album
        │   ├── dk_album
        │   ├── dl_album
        │   ├── dm_album
        │   ├── ea_album
        │   ├── eb_album
        │   ├── ec_album
        │   └── ed_album
        ├── e-e
        │   ├── ee_album
        │   ├── ef_album
        │   ├── eg_album
        │   ├── eh_album
        │   ├── ei_album
        │   ├── ej_album
        │   ├── ek_album
        │   └── el_album
        ├── e-s
        │   ├── em_album
        │   ├── m_album
        │   ├── n_album
        │   ├── o_album
        │   ├── p_album
        │   ├── q_album
        │   ├── r_album
        │   └── s_album
        └── t-z
            ├── t_album
            ├── u_album
            ├── v_album
            ├── w_album
            ├── x_album
            ├── y_album
            └── z_album

292 directories, 0 files

Hors ligne

#20 Le 31/08/2012, à 10:35

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bon alors, le script suivant fonctionne plutot bien, je crois.
J'ai retravaillé la fonction du nbre optimum à mon avis de répertoire réorganisés.
Ca donne ceci.
je continue les tests avec des noms exotiques pour voir le comportement (chiffre et autre en début de naming).
Merci vraiment à sputnick et à pingouinux qui m'ont permis de réviser chacun mes idées initiales et un grand merci à sputnick qui a fait la partie noble et très optimisée du script.

#!/bin/bash

compact_folder() {
# function developped by sputnick
    test=`ls "$1"`
    if [ "$test" = "" ]; then return; fi
    cd "$1"
    maxfiles=$2

    # on crèe un tableau
    files=( * )

    # on itère sur les fichiers
    for ((i=0; i<${#files[@]}; i++)); do
        curfile="${files[i]}"

        # on test si il reste un reste à la division de l'index/maxfiles (modulo) : multiple de maxfiles
        if ! ((i % maxfiles)); then
            lastone="${files[i+maxfiles-1]}"
            c=0
            until [[ -e "$lastone" ]]; do
                lastone="${files[i+maxfiles-1-c++]}"
            done
            curdir="${curfile:0:1}-${lastone:0:1}"
            mkdir -p "$curdir"
        fi

        mv "$curfile" "$curdir"
    done
}

function folder_read()
{
while read folder; do echo "$folder"; done < <(find "$1")
}

function folder_optimization()
{
# $1: folder to re-arrange
#
master_folder="$1"
max_initial_depth=`find "$master_folder" -printf '%d\n' | sort -n  | tail -1`
echo $max_initial_depth
depth=$(bc <<<"$max_initial_depth") #faudrait pas que je commence à $max_initial_depth-1 ?

while [ $(( depth+1 )) -gt 0 ] #je pars du plus profond en remontant jusqu'au dernier niveau
do
   while read folder
   do
      nb_folder=`find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | wc -l` # je compte son nombre de sous repertoires
      if [ $nb_folder -gt 8 ]
      then
         param=$(bc -l <<<"sqrt($nb_folder-1)+1")
         param=`echo "($param)/1" | bc` #partie entière
         compact_folder "$folder" $param #et je compacte en utilisant la fonction
      fi
   done < <(find "$master_folder" -mindepth $depth -maxdepth $depth -type d ! -name ".*" | sort -n) # je liste les répertoires ayant des sous répertoires
   depth=$(( depth-1 )) # je remonte d'un cran
done
}

folder_optimization "$1"
#folder_read "$1"
exit

Dernière modification par thurston (Le 31/08/2012, à 16:13)

Hors ligne

#21 Le 31/08/2012, à 17:48

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Bon j'ai trouvé une limitation au script de sputnick, pas très genante en réalité.
Dans le cas où on a x repertoires devant etre traités, et commencant tous par la meme lettre, le script ne fonctionne pas.
Attention, ce cas n'est pas hypothétique dans mon cas car j'avais décidé de nommer mes albums comme suit
YYYY-Album_name
Exemple: 2011-Sonic Death
A comparer le résultat du script de sputnick sur

rm -rf /tmp/Post\ Rock/*; mkdir /tmp/Post\ Rock/a{a..l}album;touch /tmp/Post\ Rock/a{a..l}album/song

résultat:

tree /tmp/Post\ Rock/
/tmp/Post Rock/
└── a-a
    ├── aaalbum
    │   └── song
    ├── abalbum
     ....
    ├── akalbum
    │   └── song
    └── alalbum
        └── song

A comparer avec

rm -rf /tmp/Post\ Rock/*; mkdir /tmp/Post\ Rock/{a..l}album;touch /tmp/Post\ Rock/{a..l}album/song

résultat

tree /tmp/Post\ Rock//tmp/Post Rock/
├── a-e
│   ├── aalbum
│   │   └── song
│   ├── balbum
│   │   └── song
│   ├── calbum
│   │   └── song
│   ├── dalbum
│   │   └── song
│   └── ealbum
│       └── song
├── f-j
│   ├── falbum
│   │   └── song
│   ├── galbum
│   │   └── song
│   ├── halbum
│   │   └── song
│   ├── ialbum
│   │   └── song
│   └── jalbum
│       └── song
└── k-l
    ├── kalbum
    │   └── song
    └── lalbum
        └── song

Dernière modification par thurston (Le 31/08/2012, à 17:49)

Hors ligne

#22 Le 31/08/2012, à 18:05

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

J'ai retravaillé ton script :

Plutôt que

    test=`ls "$1"` 
    if [ "$test" = "" ]; then return; fi

on active

shopt -s nullglob

( voir commentaires ) et on fait à la place

[[ ${subdirs[@]} ]] || return

plutot que

``

il vaut mieux utiliser

$()

, c'est plus souple et plus lisible et moins déprécié

Bon, j'ai tout revu en simple et efficace, le seul truc c'est que quand ya admettons 10 répertoires qui correspondent à a-a, il y aura au moins donc 10 répertoires dans a-a. A voir si c'est ce que tu veut ou pas :

#!/bin/bash

maxdirs=6

# si un glob est vide,
# "*" ne sera pas compté comme un élément :
shopt -s nullglob

while read dir; do
    cd "$dir"

    # on crée un tableau de répertoires
    subdirs=( */ )

    # si pas de répertoires dans le tableau on "skip"
    [[ ${subdirs[@]} ]] || continue

    # on itère sur les dossiers
    for ((i=0; i<${#subdirs[@]}; i++)); do
        curdir="${subdirs[i]}"

        # on test si il reste un reste à la division de l'index/maxdirs (modulo) : multiple de maxdirs
        if ! ((i % maxdirs)); then
            lastone="${subdirs[i+maxdirs-1]}"
            c=0
            until [[ -d "$lastone" ]]; do
                lastone="${subdirs[i+maxdirs-1-c++]}"
            done
            # utilisa tion de "parameter expansion" de bash pour recuperer les premières lettres
            renameddir="${curdir:0:1}-${lastone:0:1}"
            mkdir -p "$renameddir"
        fi

        mv "$curdir" "$renameddir"
    done
done < <(find /tmp/post-rock -mindepth 1 -depth -type d | sed 's:/[^/]\+$::' | sort -ru)

On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#23 Le 31/08/2012, à 18:27

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

ok merci pour l'optimisation. (testé intégré dans mon script, avec mon nombre "optimum" de folders cibles...(pas sûr que mon analyse résiste à une étude sérieuse, mais largement suffisant pour l'instant).
effectivement tu as vu la limitation
"Bon, j'ai tout revu en simple et efficace, le seul truc c'est que quand ya admettons 10 répertoires qui correspondent à a-a, il y aura au moins donc 10 répertoires dans a-a"

C'est en réalité peu gênant dans mon cas, car j'ai décidé de ne pas compacter les albums (seuls les artistes sous les genres), et donc le problème de l'année en début qui rassemble beaucoup d'albums (tous les 20xx-) comme partageant la première et même souvent les 3 premières lettres 201x (qui me permet d'ordonner du plus anciens au plus récent) ne se pose pas en pratique.
Merci pour le script très très efficace à l'utilisation.
A+
T

Hors ligne

#24 Le 31/08/2012, à 18:39

sputnick

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

Le but aussi c'est que tu apprenne des choses, d'où les commentaires dans le script.

N'hésite pas à rechercher ce que tu comprends pas sur le web et à poser des questions.

Par exemple les "parameter expansion" de bash c'est très puissant !

Je t(invite aussi à regarder l'option

-depth

dans

man find | less +/-depth

On ne peut pas mettre d'array dans un string!
https://sputnick.fr/

Hors ligne

#25 Le 31/08/2012, à 19:09

thurston

Re : [RESOLU]Compacter un repertoire avec de nombreux sous repertoires

oui merci pour les commentaires et le commentaire. Maintenant avec 4 momes en bas âge+  un boulot un peu beaucoup prenant + un parcours par Windows fatal donc perte seche sur bash et consorts, l'aide du forum est très appréciée, et personnaliser les scripts proposés par des experts comme vous autres est une étape qui s'étale dans le temps...enfin pour ma part au moins.
Je me suis rendu compte au contact de pingouinux récemment que je bricolais des scripts très bof vers un but (je validais en gros le cahier des charges sur résultat, avec script très limité et assez horrible) et si j'arrivais à intéresser un pro, ça donnait des scripts sympa à l'arrivée, comme le script que tu as proposé et qui reste à des années lumières de ce que je peux véritablement appréhender...pour l'instant.
En tous les cas merci
A+
T

PS: options -depth, mon script marchait pas et j'ai du croire que je l'utilisais mal, du coup l'horrible centrage entre min et max a été une solution...pas très élégante c'est le moins que l'on puisse dire...à revoir bien sûr.

EDIT: Du coup, une version correspondant 100% à mon utilisation (je compacte les artistes et genres pour naviguer rapidement dedans, en laissant le niveau album non modifié (choix perso). J'utilise donc le script de sputnick dans sa version non récursive.

#!/bin/bash

compact_folder()
{
folder2treat="$1"
maxdirs=$2
# si un glob est vide,
# "*" ne sera pas compté comme un élément :
shopt -s nullglob

#while read dir; do  #remove coment this line for recursive process
#    cd "$dir"       #remove coment this line for recursive process
cd "$folder2treat"   #coment -only- this line for recursive process

# on crée un tableau de répertoires
subdirs=( */ )

# si pas de répertoires dans le tableau on "skip"
[[ ${subdirs[@]} ]] || continue

# on itère sur les dossiers
for ((i=0; i<${#subdirs[@]}; i++)); do
   curdir="${subdirs[i]}"

   # on test si il reste un reste à la division de l'index/maxdirs (modulo) : multiple de maxdirs
   if ! ((i % maxdirs))
   then
      lastone="${subdirs[i+maxdirs-1]}"
      c=0
      until [[ -d "$lastone" ]]
      do
         lastone="${subdirs[i+maxdirs-1-c++]}"
      done
      # utilisa tion de "parameter expansion" de bash pour recuperer les premières lettres
      renameddir="${curdir:0:1}-${lastone:0:1}"
      mkdir -p "$renameddir"
   fi
   mv "$curdir" "$renameddir"
done
#done < <(find "$folder2treat" -mindepth 1 -depth -type d | sed 's:/[^/]\+$::' | sort -ru) #remove coment this line for recursive process
}

function folder_optimization()
{
# $1: folder to re-arrange
# $2: 0 process all folder levels
#     1 process all folderlevels except last one
#       (/genre/artist/album/song.mp3 > album folders are not processed)

master_folder="$1"
max_initial_depth=`find "$master_folder" -printf '%d\n' | sort -n  | tail -1`

depth=$(bc <<<"$max_initial_depth-$2-1")

while [ $depth -ge 0 ] #je pars du plus profond en remontant jusqu'au niveau maximum supérieur
do
   while read folder
   do
   #echo "$folder" under treatment, depth=$depth; sleep 0.01
      nb_folder=`find "$folder" -mindepth 1 -maxdepth 1 -type d ! -name ".*" | wc -l` # je compte son nombre de sous repertoires
      if [ $nb_folder -gt 8 ]
      then
         param=$(bc -l <<<"sqrt($nb_folder-1)+1")
         param=`echo "($param)/1" | bc` #partie entière
         #echo $param
         compact_folder "$folder" $param #et je compacte en utilisant la fonction
      fi
   done < <(find "$master_folder" -mindepth $depth -maxdepth $depth -type d ! -name ".*" | sort -n) # je liste les répertoires ayant des sous répertoires
   depth=$(( depth-1 )) # je remonte d'un cran
done
}

folder_optimization "$1" 1
exit

Dernière modification par thurston (Le 31/08/2012, à 21:01)

Hors ligne