diff --git a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java index c17e664..354b279 100644 --- a/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java +++ b/src/main/java/net/tfminecraft/tfmccore/TFMCCore.java @@ -6,7 +6,9 @@ import java.util.Random; import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.java.JavaPlugin; @@ -49,6 +51,7 @@ import net.tfminecraft.tfmccore.stones.StoneListener; import net.tfminecraft.tfmccore.tfmc.BukkitTfmcActions; import net.tfminecraft.tfmccore.tfmc.TfmcCommand; +import net.tfminecraft.tfmccore.tfmc.TfmcCreditsRoster; import net.tfminecraft.tfmccore.tfmc.TfmcConfig; import net.tfminecraft.tfmccore.tfmc.TfmcCooldowns; import net.tfminecraft.tfmccore.whistle.WhistleConfigLoader; @@ -174,7 +177,8 @@ private void registerTfmcCommand() { cooldowns.save(); } TfmcCommand tfmc = tfmcCommand = new TfmcCommand(tfmcConfig, cooldowns, new BukkitTfmcActions(this), - Clock.systemDefaultZone(), new Random(), task -> getServer().getScheduler().runTask(this, task)); + Clock.systemDefaultZone(), new Random(), task -> getServer().getScheduler().runTask(this, task), + new TfmcCreditsRoster(new File(getDataFolder(), "credits-roster.yml"))); getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> event.registrar().register(tfmc.build(), "TFMC player commands")); getServer().getPluginManager().registerEvents(new Listener() { @@ -182,6 +186,16 @@ private void registerTfmcCommand() { public void onQuit(PlayerQuitEvent event) { tfmc.onQuit(event.getPlayer()); } + + // /tfmc credits is kept out of the command tree so nobody is shown it; answer it here + // HIGH so other plugins' command gates (login, jail and the like) refuse it first + @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) + public void onCredits(PlayerCommandPreprocessEvent event) { + if (TfmcCommand.isCredits(event.getMessage())) { + event.setCancelled(true); + tfmc.credits(event.getPlayer()); + } + } }, this); } diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java index 7b98db4..8cf4ba9 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActions.java @@ -1,8 +1,14 @@ package net.tfminecraft.tfmccore.tfmc; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; @@ -25,6 +31,8 @@ import net.luckperms.api.context.DefaultContextKeys; import net.luckperms.api.context.ImmutableContextSet; import net.luckperms.api.model.user.User; +import net.luckperms.api.model.user.UserManager; +import net.luckperms.api.node.Node; import net.luckperms.api.node.NodeType; import net.luckperms.api.node.types.InheritanceNode; import net.luckperms.api.track.Track; @@ -163,6 +171,60 @@ public CompletableFuture stepTrack(Player player, String trackName, b }); } + @Override + public CompletableFuture>> trackMembers(List trackNames) { + LuckPerms api = luckPerms.get(); + if (api == null) { + return CompletableFuture.failedFuture(new IllegalStateException("LuckPerms is not available")); + } + UserManager users = api.getUserManager(); + // Searches storage, so offline players count too; one search per group on each track + Map>>>> searches = new LinkedHashMap<>(); + for (String name : trackNames) { + Track track = api.getTrackManager().getTrack(name); + List>>> groups = new ArrayList<>(); + if (track == null) { + LOGGER.warning("No LuckPerms track " + name + " for /tfmc credits"); + } else { + for (String group : track.getGroups()) { + groups.add(users.searchAll(api.getNodeMatcherFactory().key("group." + group))); + } + } + searches.put(name, groups); + } + CompletableFuture[] all = searches.values().stream().flatMap(List::stream).toArray(CompletableFuture[]::new); + return CompletableFuture.allOf(all).thenCompose(done -> { + Map> members = new LinkedHashMap<>(); + Map> names = new LinkedHashMap<>(); + searches.forEach((track, groups) -> { + Set ids = new LinkedHashSet<>(); + for (CompletableFuture>> group : groups) { + group.join().forEach((id, nodes) -> { + // Only the stored global group: the same rule track steps follow + if (nodes.stream().anyMatch(node -> node.getValue() && !node.hasExpired() && node.getContexts().isEmpty())) { + ids.add(id); + } + }); + } + members.put(track, ids); + ids.forEach(id -> names.computeIfAbsent(id, unknown -> name(users, unknown))); + }); + return CompletableFuture.allOf(names.values().toArray(CompletableFuture[]::new)).thenApply(named -> { + Map> out = new LinkedHashMap<>(); + members.forEach((track, ids) -> out.put(track, ids.stream() + .map(id -> names.get(id).join()).filter(Objects::nonNull).toList())); + return out; + }); + }); + } + + /** The name as last seen on this server (with its capitals), else LuckPerms' stored one. */ + private static CompletableFuture name(UserManager users, UUID id) { + String seen = Bukkit.getOfflinePlayer(id).getName(); + return seen != null ? CompletableFuture.completedFuture(seen) + : users.lookupUsername(id).exceptionally(error -> null); + } + @Override public FlightState startFlight(Player player, float speed) { FlightState previous = new FlightState(player.getAllowFlight(), player.isFlying(), player.getFlySpeed()); diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java index 66930b3..f0b47c8 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcActions.java @@ -1,6 +1,7 @@ package net.tfminecraft.tfmccore.tfmc; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.concurrent.CompletableFuture; @@ -51,6 +52,12 @@ public static TrackStep unchanged() { /** Moves the player one step along a LuckPerms track they are already on. */ CompletableFuture stepTrack(Player player, String track, boolean promote); + /** + * For each track, the names of every player (online or not) holding one of its groups + * globally, on duty or not. Groups held only in a server context do not count. + */ + CompletableFuture>> trackMembers(List tracks); + /** Lets the player fly at {@code speed} and returns their previous flight settings. */ FlightState startFlight(Player player, float speed); diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java index c3d7c86..bfa3f10 100644 --- a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCommand.java @@ -3,20 +3,25 @@ import java.time.Clock; import java.time.LocalDate; import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executor; +import java.util.concurrent.TimeUnit; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.logging.Logger; import java.util.random.RandomGenerator; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.bukkit.Bukkit; import org.bukkit.Material; @@ -33,6 +38,7 @@ import io.papermc.paper.command.brigadier.CommandSourceStack; import io.papermc.paper.command.brigadier.Commands; +import net.kyori.adventure.text.Component; import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder; import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; @@ -62,10 +68,20 @@ private record ParrotFlight(TfmcActions.FlightState previous, Runnable cancelExp private final RandomGenerator random; private final Executor mainThread; private final Map parrots = new ConcurrentHashMap<>(); + private final TfmcCreditsRoster creditRoster; + private volatile CompletableFuture>> creditMembers; + private volatile long creditMembersAt; /** {@code mainThread} runs LuckPerms completions, which arrive on LuckPerms worker threads. */ public TfmcCommand(TfmcConfig config, TfmcCooldowns cooldowns, TfmcActions actions, Clock clock, RandomGenerator random, Executor mainThread) { + this(config, cooldowns, actions, clock, random, mainThread, new TfmcCreditsRoster(null)); + } + + /** {@code creditRoster} remembers everyone /tfmc credits has listed. */ + public TfmcCommand(TfmcConfig config, TfmcCooldowns cooldowns, TfmcActions actions, Clock clock, + RandomGenerator random, Executor mainThread, TfmcCreditsRoster creditRoster) { + this.creditRoster = creditRoster; this.mainThread = mainThread; this.config = config; this.cooldowns = cooldowns; @@ -395,6 +411,111 @@ private void poster(Player player, String name) { () -> player.sendMessage(MINI.deserialize("There is no poster called .", Placeholder.unparsed("name", name)))); } + /** One block of /tfmc credits: its key, title and the LuckPerms tracks whose members it lists. */ + record CreditSection(String key, String title, List tracks) {} + + private static final Pattern CREDITS = Pattern.compile("/(?:tfmccore:)?tfmc\\s+credits\\s*", Pattern.CASE_INSENSITIVE); + + /** + * Whether a typed command is /tfmc credits. That subcommand is deliberately not in the command + * tree, so the client never suggests or completes it; TFMCCore answers it before Brigadier does. + */ + public static boolean isCredits(String message) { + return message != null && CREDITS.matcher(message.trim()).matches(); + } + + /** The sections in tfmc.yml credits.sections, highest first; staff then helpers when none are set. */ + List creditSections() { + List sections = new ArrayList<>(); + for (String key : config.keys("credits.sections")) { + String base = "credits.sections." + key; + sections.add(new CreditSection(key, config.string(base + ".title", key), config.lines(base + ".tracks"))); + } + if (sections.isEmpty()) { + sections.add(new CreditSection("staff", "<#f1c40f>Staff", List.of("staff"))); + sections.add(new CreditSection("helpers", "<#ff00cc>Helpers", List.of("helper+", "helper"))); + } + return sections; + } + + /** + * Shows the credits: everyone on each section's tracks and everyone the roster remembers (so + * those who step down stay listed), each player once in their highest section; then the extra + * lines. Members are looked up at most every credits.cache-seconds, since each lookup searches + * LuckPerms storage. + */ + public void credits(Player player) { + List sections = creditSections(); + List tracks = sections.stream().flatMap(section -> section.tracks().stream()).distinct().toList(); + long now = clock.millis(); + CompletableFuture>> members = creditMembers; + // A live tfmc.yml without the credits section still caches (300 s), and a lookup still running is shared. + long cacheSeconds = (long) config.decimal("credits.cache-seconds", 300); + if (members == null || members.isCompletedExceptionally() + || (members.isDone() && now - creditMembersAt >= cacheSeconds * 1000L)) { + // A lookup that hangs for a minute fails, so everyone waiting gets the remembered names instead. + members = creditMembers = actions.trackMembers(tracks).orTimeout(60, TimeUnit.SECONDS); + creditMembersAt = now; + } + members.whenCompleteAsync((found, error) -> { + if (error != null) { + LOGGER.warning("Failed to look up the credits: " + error.getMessage()); + } + showCredits(player, sections, error == null ? found : Map.of()); + }, mainThread); + } + + private void showCredits(Player player, List sections, Map> members) { + Map ranks = new HashMap<>(); + for (int i = 0; i < sections.size(); i++) { + ranks.putIfAbsent(sections.get(i).key(), i); + } + // Remember who is on the tracks now; the roster keeps their highest section and best spelling + boolean changed = false; + for (CreditSection section : sections) { + for (String track : section.tracks()) { + for (String name : members.getOrDefault(track, List.of())) { + changed |= creditRoster.record(name, section.key(), ranks); + } + } + } + if (changed) { + creditRoster.save(); + } + Set excluded = new HashSet<>(); + config.lines("credits.exclude").forEach(name -> excluded.add(name.toLowerCase(Locale.ROOT))); + Map roster = creditRoster.players(); + + send(player, "credits.header"); + String nameFormat = config.string("credits.name", ""); + String separator = config.string("credits.separator", ", "); + for (int i = 0; i < sections.size(); i++) { + CreditSection section = sections.get(i); + // The roster is in the order people joined; the top section keeps that, the rest are alphabetical + List names = roster.entrySet().stream() + .filter(entry -> entry.getValue().section().equals(section.key()) && !excluded.contains(entry.getKey())) + .map(entry -> entry.getValue().name()) + .collect(Collectors.toCollection(ArrayList::new)); + if (names.isEmpty()) { + continue; + } + if (i > 0) { + names.sort(String.CASE_INSENSITIVE_ORDER); + } + Component line = Component.empty(); + for (int n = 0; n < names.size(); n++) { + if (n > 0) { + line = line.append(MINI.deserialize(separator)); + } + line = line.append(MINI.deserialize(nameFormat, Placeholder.unparsed("name", names.get(n)))); + } + player.sendMessage(MINI.deserialize(section.title())); + player.sendMessage(line); + } + send(player, "credits.extra"); + send(player, "credits.footer"); + } + private void update(Player player, CompletableFuture change, String successPath) { change.whenCompleteAsync((done, error) -> { if (error != null) { diff --git a/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java new file mode 100644 index 0000000..b1c2a89 --- /dev/null +++ b/src/main/java/net/tfminecraft/tfmccore/tfmc/TfmcCreditsRoster.java @@ -0,0 +1,103 @@ +package net.tfminecraft.tfmccore.tfmc; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.StandardCopyOption; +import java.util.LinkedHashMap; +import java.util.Locale; +import java.util.Map; +import java.util.logging.Logger; + +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.configuration.file.YamlConfiguration; + +/** + * Everyone /tfmc credits has listed, with the highest section they reached, so staff and helpers + * who later step down stay in the credits. Kept in credits-roster.yml; a null file keeps it in memory. + */ +public final class TfmcCreditsRoster { + + /** A remembered player: the section key they reached and their name as last spelled. */ + public record Entry(String section, String name) {} + + private static final Logger LOGGER = Logger.getLogger("TFMCCore"); + + private final File file; + private final Map players = new LinkedHashMap<>(); + /** The file could not be read: it is left as it is and never overwritten until fixed and reloaded. */ + private boolean readOnly; + + public TfmcCreditsRoster(File file) { + this.file = file; + if (file != null && file.isFile()) { + YamlConfiguration yaml = new YamlConfiguration(); + try { + yaml.load(file); + } catch (IOException | InvalidConfigurationException e) { + readOnly = true; + LOGGER.warning("Could not read " + file.getName() + " (" + e.getMessage() + + "); it is left untouched and not saved until it is fixed and the server restarts."); + return; + } + ConfigurationSection saved = yaml.getConfigurationSection("players"); + if (saved != null) { + for (String key : saved.getKeys(false)) { + String section = saved.getString(key + ".section", ""); + if (!section.isBlank()) { + players.put(key.toLowerCase(Locale.ROOT), new Entry(section, saved.getString(key + ".name", key))); + } + } + } + } + } + + /** Everyone remembered, in the order they joined their section. */ + public Map players() { + return java.util.Collections.unmodifiableMap(new LinkedHashMap<>(players)); + } + + /** + * Remembers the player in the section if it ranks higher than the one they reached before + * (lower {@code rank} is higher), and keeps the best spelling of their name. True when changed. + */ + public boolean record(String name, String section, Map ranks) { + String key = name.toLowerCase(Locale.ROOT); + Entry old = players.get(key); + String keptSection = old == null || ranks.getOrDefault(section, Integer.MAX_VALUE) + < ranks.getOrDefault(old.section(), Integer.MAX_VALUE) ? section : old.section(); + String keptName = old == null || !name.equals(name.toLowerCase(Locale.ROOT)) ? name : old.name(); + Entry entry = new Entry(keptSection, keptName); + if (entry.equals(old)) { + return false; + } + if (old != null && !old.section().equals(keptSection)) { + players.remove(key); + } + players.put(key, entry); + return true; + } + + public void save() { + if (file == null || readOnly) { + return; + } + YamlConfiguration out = new YamlConfiguration(); + out.options().setHeader(java.util.List.of( + "Everyone /tfmc credits has listed and the highest section they reached, so former staff", + "and helpers stay in the credits. To drop someone, add them to credits.exclude in tfmc.yml.")); + players.forEach((key, entry) -> { + out.set("players." + key + ".section", entry.section()); + out.set("players." + key + ".name", entry.name()); + }); + // Written beside it and moved into place, so a crash mid-write never leaves half a roster. + File temp = new File(file.getParentFile(), file.getName() + ".tmp"); + try { + out.save(temp); + Files.move(temp.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING); + } catch (IOException e) { + LOGGER.warning("Failed to save " + file.getName() + ": " + e.getMessage()); + } + } +} diff --git a/src/main/resources/tfmc.yml b/src/main/resources/tfmc.yml index ad76df0..dfe0d3a 100644 --- a/src/main/resources/tfmc.yml +++ b/src/main/resources/tfmc.yml @@ -176,6 +176,29 @@ track-messages: removed: "You are no longer on the track." failed: "Your status could not be changed." +# /tfmc credits is deliberately hidden: it is not in the command tree, so it is never suggested, +# tab-completed or listed. Each section lists everyone holding one of its LuckPerms tracks' groups +# globally (on duty or not) and everyone it ever listed (credits-roster.yml), each player once in +# their highest section. Then extra (credits other licences ask for, and anyone else) and footer. +# exclude: names never listed. Members are looked up at most every cache-seconds. +credits: + cache-seconds: 300 + header: " <#b854f2>❖ <#f4c542>TFMC <#d972f3>Credits <#b854f2>❖ " + sections: + staff: + title: "<#f1c40f>Staff" + tracks: [staff] + helpers: + title: "<#ff00cc>Helpers" + tracks: [helper+, helper] + name: "" + separator: " • " + exclude: [] + extra: + - "<#5fb8ff>Music" + - "SOUND AIRYLUVS by ISAo" + footer: " " + # /tfmc poster runs the command as the player. posters: Zerratoris1: "images create https://cdn.imgchest.com/files/yxkczwm8rq7.jpg 42.74553571428" diff --git a/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java b/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java index e17bde8..5655832 100644 --- a/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/PluginLifecycleCoverageTest.java @@ -78,6 +78,7 @@ import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.Player; import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerCommandPreprocessEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.PluginDescriptionFile; @@ -326,6 +327,18 @@ void startupRegistersCommandsListenersAndTheActualLifecycleAndQuitCallbacks() th new PlayerQuitEvent( rig.player, Component.empty(), PlayerQuitEvent.QuitReason.DISCONNECTED)); verify(rig.commands.constructed().getFirst()).onQuit(rig.player); + var onCredits = quit.getClass().getDeclaredMethod("onCredits", PlayerCommandPreprocessEvent.class); + onCredits.setAccessible(true); + PlayerCommandPreprocessEvent credits = mock(PlayerCommandPreprocessEvent.class); + when(credits.getMessage()).thenReturn("/tfmc credits"); + when(credits.getPlayer()).thenReturn(rig.player); + onCredits.invoke(quit, credits); + verify(credits).setCancelled(true); + verify(rig.commands.constructed().getFirst()).credits(rig.player); + PlayerCommandPreprocessEvent other = mock(PlayerCommandPreprocessEvent.class); + when(other.getMessage()).thenReturn("/tfmc patreon"); + onCredits.invoke(quit, other); + verify(other, never()).setCancelled(true); rig.plugin.onDisable(); diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java index d03f603..26074d3 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/BukkitTfmcActionsCoverageTest.java @@ -7,6 +7,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.UUID; import java.util.concurrent.CompletableFuture; @@ -286,4 +287,59 @@ private PermissionNode permission(String name, ImmutableContextSet context) { when(node.getContexts()).thenReturn(context); return node; } + + @Test + @SuppressWarnings({"unchecked", "rawtypes"}) + void trackMembersFindEveryoneWithAGlobalGroupOnTheTrackByName() { + LuckPerms api = mock(LuckPerms.class, RETURNS_DEEP_STUBS); + Track staff = mock(Track.class); + when(staff.getGroups()).thenReturn(List.of("staff_player", "staff")); + when(api.getTrackManager().getTrack("staff")).thenReturn(staff); + when(api.getTrackManager().getTrack("missing")).thenReturn(null); + var offDuty = mock(net.luckperms.api.node.matcher.NodeMatcher.class); + var onDuty = mock(net.luckperms.api.node.matcher.NodeMatcher.class); + when(api.getNodeMatcherFactory().key("group.staff_player")).thenReturn(offDuty); + when(api.getNodeMatcherFactory().key("group.staff")).thenReturn(onDuty); + UUID alice = UUID.randomUUID(), devOnly = UUID.randomUUID(), dave = UUID.randomUUID(), lapsed = UUID.randomUUID(); + Map> offDutyFound = new java.util.LinkedHashMap<>(); + offDutyFound.put(alice, List.of(node(true, false, true))); + offDutyFound.put(devOnly, List.of(node(true, false, false))); + Map> onDutyFound = new java.util.LinkedHashMap<>(); + onDutyFound.put(alice, List.of(node(true, false, true))); + onDutyFound.put(dave, List.of(node(true, false, true))); + onDutyFound.put(lapsed, List.of(node(true, true, true), node(false, false, true))); + when(api.getUserManager().searchAll((net.luckperms.api.node.matcher.NodeMatcher) offDuty)) + .thenReturn(CompletableFuture.completedFuture(offDutyFound)); + when(api.getUserManager().searchAll((net.luckperms.api.node.matcher.NodeMatcher) onDuty)) + .thenReturn(CompletableFuture.completedFuture(onDutyFound)); + when(api.getUserManager().lookupUsername(dave)).thenReturn(CompletableFuture.completedFuture("dave")); + try (var bukkit = mockStatic(Bukkit.class)) { + org.bukkit.OfflinePlayer seen = mock(org.bukkit.OfflinePlayer.class); + when(seen.getName()).thenReturn("Alice"); + org.bukkit.OfflinePlayer unseen = mock(org.bukkit.OfflinePlayer.class); + bukkit.when(() -> Bukkit.getOfflinePlayer(alice)).thenReturn(seen); + bukkit.when(() -> Bukkit.getOfflinePlayer(dave)).thenReturn(unseen); + + Map> members = + new BukkitTfmcActions(null, () -> api).trackMembers(List.of("staff", "missing")).join(); + + // Alice once though on two groups; a dev-only group, a lapsed and a negated one do not count + assertEquals(Map.of("staff", List.of("Alice", "dave"), "missing", List.of()), members); + } + CompletionException failure = + assertThrows( + CompletionException.class, + () -> new BukkitTfmcActions(null, () -> null).trackMembers(List.of("staff")).join()); + assertEquals("LuckPerms is not available", failure.getCause().getMessage()); + } + + private static Node node(boolean value, boolean expired, boolean global) { + Node node = mock(Node.class); + ImmutableContextSet contexts = mock(ImmutableContextSet.class); + when(contexts.isEmpty()).thenReturn(global); + when(node.getValue()).thenReturn(value); + when(node.hasExpired()).thenReturn(expired); + when(node.getContexts()).thenReturn(contexts); + return node; + } } diff --git a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java index 1bdb01f..e37c300 100644 --- a/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java +++ b/src/test/java/net/tfminecraft/tfmccore/tfmc/TfmcCommandTest.java @@ -66,6 +66,10 @@ class TfmcCommandTest { private int packsSent; private boolean packRequired; private long clock = NOW.toEpochMilli(); + // Track to the names LuckPerms holds on it, for /tfmc credits + private final Map> members = new HashMap<>(); + private RuntimeException membersFailure; + private int memberLookups; private CommandDispatcher dispatcher; private TfmcConfig config; @@ -93,6 +97,137 @@ public int nextInt(int bound) { dispatcher.getRoot().addChild(command.build()); } + @Test + void creditsStayOutOfTheTreeAndListEachPlayerOnceInTheirHighestSection() throws Exception { + assertTrue(TfmcCommand.isCredits("/tfmc credits")); + assertTrue(TfmcCommand.isCredits(" /TFMC Credits ")); + assertTrue(TfmcCommand.isCredits("/tfmccore:tfmc credits")); + assertFalse(TfmcCommand.isCredits("/tfmc credits now")); + assertFalse(TfmcCommand.isCredits("/tfmc creditss")); + assertFalse(TfmcCommand.isCredits("/tfmc")); + assertFalse(TfmcCommand.isCredits("/credits")); + assertFalse(TfmcCommand.isCredits(null)); + TestPlayer staff = everything("Staffer"); + assertFalse(visible(staff).contains("credits"), "Never suggested, not even to staff"); + assertThrows(CommandSyntaxException.class, () -> run(staff, "tfmc credits"), "Answered before the tree, not by it"); + + credits("exclude: []", "exclude: [TestBot, AltOfZed]"); + members.put("staff", List.of("Zed", "Alice", "altofzed")); + members.put("helper+", List.of("alice", "Bob")); + members.put("helper", List.of("carl", "Bob", "testbot")); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + assertTrue(steve.messages.isEmpty(), "Shown on the main thread"); + runMainThread(); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Staff", "Zed \u2022 Alice", "Helpers", "Bob \u2022 carl", "Music", "SOUND AIRYLUVS by ISAo", ""), + trimmed(steve)); + assertFalse(steve.messages.stream().anyMatch(line -> line.contains("http") || line.contains(".com")), "No links"); + + // Looked up once per cache-seconds, so the second call still shows the first list + members.put("helper", List.of("Dana")); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(1, memberLookups); + assertTrue(steve.messages.contains("Bob \u2022 carl"), "Still the cached list"); + } + + @Test + void formerStaffAndHelpersStayInTheCreditsInTheHighestSectionTheyReached() throws Exception { + credits("cache-seconds: 300", "cache-seconds: 0"); + members.put("staff", List.of("Erin", "Alice")); + members.put("helper", List.of("Bob", "Carl")); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + runMainThread(); + // Next lookup: Alice and Carl stepped down, Bob became staff, Dana joined the helpers + clock += 1; + members.clear(); + members.put("staff", List.of("Erin", "bob")); + members.put("helper", List.of("Dana")); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(2, memberLookups); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Staff", "Erin \u2022 Alice \u2022 Bob", "Helpers", "Carl \u2022 Dana", "Music", + "SOUND AIRYLUVS by ISAo", ""), trimmed(steve)); + } + + @Test + void creditsWithoutLuckPermsStillShowTheExtraLinesAndTryAgainNextTime() throws Exception { + membersFailure = new IllegalStateException("LuckPerms is not available"); + TestPlayer steve = player("Steve"); + command.credits(steve.player); + runMainThread(); + assertEquals(List.of("\u2756 TFMC Credits \u2756", "Music", "SOUND AIRYLUVS by ISAo", ""), trimmed(steve)); + membersFailure = null; + members.put("staff", List.of("Alice")); + steve.messages.clear(); + command.credits(steve.player); + runMainThread(); + assertEquals(2, memberLookups); + assertTrue(steve.messages.contains("Alice")); + + // Without a credits section: staff, then helpers, in the TAB rank colours + config.loadFromString("messages: {}"); + assertEquals(List.of(new TfmcCommand.CreditSection("staff", "<#f1c40f>Staff", List.of("staff")), + new TfmcCommand.CreditSection("helpers", "<#ff00cc>Helpers", List.of("helper+", "helper"))), + command.creditSections()); + } + + /** Loads the shipped tfmc.yml with each pair of strings replaced (old, new, old, new...). */ + private void credits(String... replacements) throws Exception { + String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); + for (int i = 0; i < replacements.length; i += 2) { + assertEquals(1, yaml.split(java.util.regex.Pattern.quote(replacements[i]), -1).length - 1, replacements[i]); + yaml = yaml.replace(replacements[i], replacements[i + 1]); + } + config.loadFromString(yaml); + } + + @Test + void theCreditsRosterIsSavedAndReadBack(@org.junit.jupiter.api.io.TempDir Path dir) { + java.io.File file = dir.resolve("credits-roster.yml").toFile(); + Map ranks = Map.of("staff", 0, "helpers", 1); + TfmcCreditsRoster roster = new TfmcCreditsRoster(file); + assertTrue(roster.record("bob", "helpers", ranks)); + assertTrue(roster.record("Cy", "helpers", ranks)); + assertTrue(roster.record("Ann", "staff", ranks)); + assertTrue(roster.record("Bob", "helpers", ranks), "A spelling with capitals wins"); + assertFalse(roster.record("bob", "helpers", ranks), "and is kept over a lowercase one"); + assertTrue(roster.record("bob", "staff", ranks)); + assertFalse(roster.record("Bob", "helpers", ranks), "Never moved down"); + assertEquals(List.of("cy", "ann", "bob"), List.copyOf(roster.players().keySet()), "Moving up puts them last"); + roster.save(); + TfmcCreditsRoster read = new TfmcCreditsRoster(file); + assertEquals(List.of("cy", "ann", "bob"), List.copyOf(read.players().keySet())); + assertEquals(new TfmcCreditsRoster.Entry("staff", "Bob"), read.players().get("bob")); + assertTrue(new TfmcCreditsRoster(dir.resolve("none.yml").toFile()).players().isEmpty()); + new TfmcCreditsRoster(null).save(); + } + + @Test + void anUnreadableRosterIsNeverOverwritten(@org.junit.jupiter.api.io.TempDir Path dir) throws Exception { + Path file = dir.resolve("credits-roster.yml"); + String broken = "players:\n bob: [unclosed\n"; + Files.writeString(file, broken); + TfmcCreditsRoster roster = new TfmcCreditsRoster(file.toFile()); + assertTrue(roster.players().isEmpty()); + assertTrue(roster.record("Ann", "staff", Map.of("staff", 0))); + roster.save(); + assertEquals(broken, Files.readString(file), "The hand-edited file is kept as it was"); + Path blocked = dir.resolve("blocked"); + Files.createDirectories(blocked.resolve("inside")); + TfmcCreditsRoster unwritable = new TfmcCreditsRoster(blocked.toFile()); + assertTrue(unwritable.record("Ann", "staff", Map.of("staff", 0))); + unwritable.save(); + assertTrue(Files.isDirectory(blocked.resolve("inside")), "A failed save is only logged"); + } + + private static List trimmed(TestPlayer player) { + return player.messages.stream().map(String::trim).toList(); + } + @Test void conditionalEventsPathsParseAndCompleteWithoutRunningCoreActions() throws Exception { String yaml = Files.readString(Path.of("src/main/resources/tfmc.yml")); @@ -713,6 +848,14 @@ public Optional highestTrack(Player player, List tracks) { return Optional.ofNullable(highestTracks.get(player.getName())).filter(tracks::contains); } + @Override + public CompletableFuture>> trackMembers(List tracks) { + memberLookups++; + assertEquals(List.of("staff", "helper+", "helper"), tracks); + if (membersFailure != null) return CompletableFuture.failedFuture(membersFailure); + return CompletableFuture.completedFuture(Map.copyOf(members)); + } + @Override public CompletableFuture stepTrack(Player player, String track, boolean promote) { trackSteps.add(player.getName() + " " + track + " " + (promote ? "promote" : "demote"));