Sort search results by pack and bot name.

diff --git a/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java b/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java
index eaaef23..95425d0 100644 (file)
--- a/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java
+++ b/src/main/java/net/pterodactylus/xdcc/ui/stdin/CommandReader.java
@@ -21,10 +21,13 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Set;
+import java.util.regex.Pattern;
 
 import net.pterodactylus.irc.Connection;
 import net.pterodactylus.irc.DccReceiver;
@@ -39,6 +42,7 @@ import net.pterodactylus.xdcc.data.Bot;
 import net.pterodactylus.xdcc.data.Download;
 import net.pterodactylus.xdcc.data.Pack;
 
+import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.common.eventbus.Subscribe;
@@ -308,6 +312,57 @@ public class CommandReader extends AbstractExecutionThreadService {
        /** Container for result information. */
        private static class Result implements Comparable<Result> {
 
+               /** {@link Predicate} that matches {@link Result}s that contain an archive. */
+               private static final Predicate<Result> isArchive = new Predicate<Result>() {
+
+                       /** All suffixes that are recognized as archives. */
+                       private final List<String> archiveSuffixes = Arrays.asList("rar", "tar", "zip", "tar.gz", "tar.bz2", "tar.lzma", "7z");
+
+                       @Override
+                       public boolean apply(Result result) {
+                               for (String suffix : archiveSuffixes) {
+                                       if (result.pack().name().toLowerCase().endsWith(suffix)) {
+                                               return true;
+                                       }
+                               }
+                               return false;
+                       }
+               };
+
+               /**
+                * {@link Comparator} for bot nicknames. It comprises different strategies:
+                * one name pattern is preferred (and thus listed first), one pattern is
+                * disliked (and thus listed last), the rest is sorted alphabetically.
+                */
+               private static final Comparator<String> botNameComparator = new Comparator<String>() {
+
+                       /** Regular expression pattern for preferred names. */
+                       private final Pattern preferredNames = Pattern.compile("(?i)[^\\w]EUR?[^\\w]");
+
+                       /** Regular expression pattern for disliked names. */
+                       private final Pattern dislikedNames = Pattern.compile("(?i)[^\\w]USA?[^\\w]");
+
+                       @Override
+                       public int compare(String leftBotName, String rightBotName) {
+                               /* preferred names to the front! */
+                               if (preferredNames.matcher(leftBotName).find() && !preferredNames.matcher(rightBotName).find()) {
+                                       return -1;
+                               }
+                               if (preferredNames.matcher(rightBotName).find() && !preferredNames.matcher(leftBotName).find()) {
+                                       return 1;
+                               }
+                               /* disliked names to the back. */
+                               if (dislikedNames.matcher(leftBotName).find() && !dislikedNames.matcher(rightBotName).find()) {
+                                       return 1;
+                               }
+                               if (dislikedNames.matcher(rightBotName).find() && !dislikedNames.matcher(leftBotName).find()) {
+                                       return -1;
+                               }
+                               /* rest is sorted by name. */
+                               return leftBotName.compareToIgnoreCase(rightBotName);
+                       }
+               };
+
                /** The bot carrying the pack. */
                private final Bot bot;
 
@@ -355,7 +410,14 @@ public class CommandReader extends AbstractExecutionThreadService {
 
                @Override
                public int compareTo(Result result) {
-                       return pack().name().compareToIgnoreCase(result.pack().name());
+                       if (isArchive.apply(this) && !isArchive.apply(result)) {
+                               return 1;
+                       }
+                       if (!isArchive.apply(this) && isArchive.apply(result)) {
+                               return -1;
+                       }
+                       /* sort by bot name. */
+                       return botNameComparator.compare(bot().name(), result.bot().name());
                }
 
        }