Mise à jour 19/06/2016 : version 1.3.1 disponible ici !
Il y a quelques temps, j'ai réalisé que certains de mes dossiers contenaient parfois de nombreux exemplaires du même fichier. Jusque-là rien d'étonnant. Mais après un rapide nettoyage manuel, j'ai aussi réalisé que cela me prenait pas mal de place et que la méthode manuelle d'élimination était assez laborieuse !
Oui, rien d'étonnant non plus en fait.
Toujours est-il que même en achetant régulièrement de nouveaux disques, il est contre-productif d'entasser des centaires de doublons numériques de ses fichiers.
Je me suis mis alors à chercher un logiciel - libre, et multi-plateforme - qui permettait de parcourir des dossiers en détectant les doublons dans leur contenu. Chose importante, je souhaitais également que l'affichage permette de déterminer rapidement quel est LE fichier à conserver, et de supprimer tous les autres. Utilisant régulièrement la recherche de doublon de XnView ou d'autres logiciels similaires, je savais au moins ce que je ne voulais pas : quelque chose se voulant simple mais se révélant trop laborieux à utiliser.
Et surtout : la présence de cases à cocher serait rédhibitoire, ni plus ni moins. Il n'y a rien de pire que de devoir cocher un par un tous les fichiers que l'on souhaite supprimer.
Avec des contraintes aussi fortes mes recherches se sont forcément soldées par des échecs. Je me suis alors dit qu'il ne devait pas être très compliqué d'implémenter ce concept moi-même.
J'avais partiellement raison : implémenter le concept n'était effectivement pas complexe. Mais coder l'interface qui va autour s'est révélé largement plus casse-tête. Enfin, l'optimisation - de l'empreinte mémoire notamment - est également une part importante à laquelle je n'avais pas initialement pensé, et qui est pourtant indispensable (ce dernier point est d'ailleurs largement incomplet au stade actuel).
Maquette de l'agencement général
Le concept
Ma vision était de présenter les résultats sous forme d'arbre dont les branches seraient la hiérarchie des dossiers, les "feuilles" seraient les fichiers et les "sous-feuilles" les doublons de celui-ci. Un menu contextuel permettrait ainsi de supprimer en deux clics tous les doublons.
Au fil du développement, j'ai finalement opté pour un double-arbre dont les sélections seraient synchronisées de la manière suivante : en cliquant sur une sous-feuille (un doublon) dans un arbre, l'autre développerait automatiquement la branche dont ce doublon serait la feuille (le fichier de base).
Pour comprendre cela, il faut noter que les fichiers dans les arbres apparaissent plusieurs fois : une fois en tant que fichier "de base" (feuille) et ensuite autant de fois que le fichier n'a de doublons, en tant que sous-feuille de chacun d'eux.
Cas d'utilisation principal
Prenons un exemple simple : dans un même répertoire R deux fichiers A et B, et trois "doublons" A1, A2, et B1. Inutile de dire ici qui est le doublon de qui.
Le noeud représentant le répertoire R aura ainsi 5 enfants : A, B, A1, A2 et B1.
- La feuille A aura pour enfants A1 et A2.
- La feuille B aura pour enfant B1
- La feuille A1 aura pour enfants A et A2
- La feuille A2 aura pour enfants A et A1
- La feuille B1 aura pour enfant B
(l'ordre alphabétique de rigueur n'est pas respecté dans cet exemple)
Maquette du concept d'arbre de résultats
Ce cas est volontairement simpliste. Dans la réalité il peut arriver que plusieurs milliers de fichiers apparaissent dans l'arbre. On obtient alors un arbre excessivement haut, et donc très difficile à parcourir.
Le but d'avoir ici deux arbres synchronisés permet de sélectionner dans le premier le fichier "doublon" (sous-feuille) que l'on souhaite conserver, ce qui sélectionne dans le second ce même fichier mais en tant que fichier "de base" (feuille). Le menu contextuel permet ensuite de supprimer l'ensemble des doublons supplémentaires en deux clics.
En reprenant l'exemple précédent, supposons que je parcoure l'arbre (supposément très haut) et analyse les doublons du fichier A. Je souhaite ne conserver que le fichier A2, et donc supprimer A et A1.
- Je clique donc sur la quatrième ligne [1].
- Le second arbre réagit instantanément à cette action et sélectionne la ligne 5 [2] (hormis celle-ci toutes les autres branches sont réduites pour faciliter la lisibilité).
- Un clic-droit sur cette ligne affiche ensuite un menu-contextuel me permettant de supprimer tous les doublons de A2 [3].
- Ceci fait, les deux arbres sont mis à jour et les branches associées à ces fichiers disparaissent.
Principe des arbres de résultats synchronisés
L'intérêt de ce fonctionnement pour moi est qu'il m'est plus facile (et surtout plus rapide) de vérifier l'emplacement d'un fichier dans un arbre que dans un libellé contenant le chemin complet (du type "/chemin/vers/mon/dossier/contenant/mon/fichier/A".
Chaque nom de dossier se détache mieux, ce qui est pratique lorsqu'on a des noms de dossiers proches ("/chemin/vers/mon/dossier1/contenant/mon/fichier/A1").
Si cela n'était pas suffisamment clair, je précise que cette fonctionnalité répond à mes besoins particuliers. Mais je pense que ceux-ci ne sont pas non plus originaux au point de n'intéresser personne d'autre.
JDuplicateFinder
Pour mon développement j'ai utilisé Java et sa bibliothèque Swing, seul langage que je maîtrise suffisamment pour ne pas bloquer inutilement sur de bêtes aspects d'implémentation.
J'ai réutilisé le plugin WindowBuilder pour Eclipse afin de mettre en place rapidement les éléments de l'interface utilisateur. Je reste assez bluffé par les possibilités de ce module en terme de layouting WYSIWYG. Bien sûr, tout ne peut pas être réglé avec du D&D et des listes déroulantes, j'ai donc dû compléter certains points directement dans le code.
L'application sous Linux (Mate)
Fonctionnalités
Les principales fonctionnalités disponibles dans cette version 1.0 sont les suivantes :
- Recherche de doublons dans 1 à N dossiers sources
- Trois comparateurs disponibles combinables :
- Taille de fichier
- Digest (MD5, SHA1, etc.; taille du chunk utilisé configurable, 512 Kio par défaut)
- Date de fichier (création ou modification)
- Définition de filtres d'exclusion sur les noms ou chemins de fichiers
- Affichage des détails des fichiers sur simple clic (nom, chemin, taille, mimetype, dates de création et modification)
Mis à part le comparateur "Digest" pour qui deux fichiers ne peuvent être que totalement similaires ou totalement différents, il est possible de définir des "marges" en octets, kibioctets, ou pourcentage pour la taille, ou en secondes, minutes, heures ou jours pour la date.
Chaque doublon trouvé possèdera donc un "score" de similiarité (sur 100) qui sera d'autant plus faible qu'il sera proche de la limite inférieure ou supérieure définies par cette marge.
Exemple de recherche des doublons par date
Ce score est visible en préfixe dans les sous-feuilles de l'arbre, mais une icône de couleur permet également d'identifier rapidement les doublons les plus pertinents pour un fichier donné.
Détail des scores de similarité
Chaque comparateur possède également un "poids" qui va influencer le score de comparaison des fichiers si plusieurs comparateurs sont actifs pour une même recherche. Ce score devient alors la moyenne pondérée des similarités détectées par les comparateurs.
Détail des poids des comparateurs
Téléchargement
Le résultat est un JAR dont l'archive est téléchargable ici :
(1,78 Mo)
Et le code source disponible sur Github :
https://github.com/nanawel/jduplicatefinder
Je n'ai pour l'instant pas pris la peine de rédiger un manuel de 300 pages pour expliquer son utilisation, mais celle-ci reste en grande partie assez intuitive :)
À noter que s'il n'est pas (encore) possible de préparamétrer les comparateurs et autres options de configuration au lancement, il est néanmoins possible de passer au JAR la liste des dossiers cibles.
Pour cela, on utilisera la syntaxe suivante :
$ java -jar jduplicatefinder.jar "/home/user" "/tmp/folder"
sous Linux, ou
> java -jar jduplicatefinder.jar "C:\\" "D:\\Games"
sous Windows (attention dans ce cas à bien doubler les backslashs ou à utiliser des slashs à la place).
Si la mémoire allouée par défaut ne suffisait pas (message d'erreur "Java heap space" ou autre au cours de la recherche), il est possible d'augmenter celle-ci depuis la ligne de commande :
$ java -jar -Xmx512m jduplicatefinder.jar
pour autoriser jusqu'à 512 Mo dans cet exemple. La bonne application de ce paramètre est visible en bas à droite de la fenêtre.
J'ai effectué pas mal de tests et je considère cette version suffisamment stable pour la mettre à disposition.
Je ne peux cependant pas fournir de garanties si par malheur cela invoque les démons des Enfers, ouvre un trou noir dans votre salon ou simplement endommage certaines de vos données ! (j'ai néanmoins plus d'assurance sur ce dernier point, avouez que c'est plutôt rassurant quand même)
Si vous trouvez un bug ou avez des suggestions d'améliorations, utilisez le bugtracker mis à disposition sur Github.
Bon dédoublonage !
