119 lines
3.9 KiB
Java
119 lines
3.9 KiB
Java
package tools.messages;
|
|
|
|
import com.google.common.base.Preconditions;
|
|
import com.google.common.collect.HashMultimap;
|
|
import com.google.common.collect.Multimap;
|
|
import fr.xephi.authme.message.MessageKey;
|
|
import org.bukkit.configuration.MemorySection;
|
|
import org.bukkit.configuration.file.FileConfiguration;
|
|
import org.bukkit.configuration.file.YamlConfiguration;
|
|
|
|
import java.io.File;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* Verifies a message file's keys to ensure that it is in sync with {@link MessageKey}, i.e. that the file contains
|
|
* all keys and that it doesn't have any unknown ones.
|
|
*/
|
|
public class MessageFileVerifier {
|
|
|
|
private final File messagesFile;
|
|
private final Set<String> unknownKeys = new HashSet<>();
|
|
private final Set<MessageKey> missingKeys = new HashSet<>();
|
|
private final Multimap<MessageKey, String> missingTags = HashMultimap.create();
|
|
|
|
/**
|
|
* Create a verifier that verifies the given messages file.
|
|
*
|
|
* @param messagesFile The messages file to process
|
|
*/
|
|
public MessageFileVerifier(File messagesFile) {
|
|
Preconditions.checkArgument(messagesFile.exists(), "Message file '" + messagesFile + "' does not exist");
|
|
this.messagesFile = messagesFile;
|
|
verifyKeys();
|
|
}
|
|
|
|
/**
|
|
* Return the list of unknown keys, i.e. the list of keys present in the file that are not
|
|
* part of the {@link MessageKey} enum.
|
|
*
|
|
* @return List of unknown keys
|
|
*/
|
|
public Set<String> getUnknownKeys() {
|
|
return unknownKeys;
|
|
}
|
|
|
|
/**
|
|
* Return the list of missing keys, i.e. all keys that are part of {@link MessageKey} but absent
|
|
* in the messages file.
|
|
*
|
|
* @return The list of missing keys in the file
|
|
*/
|
|
public Set<MessageKey> getMissingKeys() {
|
|
return missingKeys;
|
|
}
|
|
|
|
/**
|
|
* Return the collection of tags the message key defines that aren't present in the read line.
|
|
*
|
|
* @return Collection of missing tags per message key
|
|
*/
|
|
public Multimap<MessageKey, String> getMissingTags() {
|
|
return missingTags;
|
|
}
|
|
|
|
/**
|
|
* @return true if the verifier has found an issue with the analyzed file, false otherwise
|
|
*/
|
|
public boolean hasErrors() {
|
|
return !missingKeys.isEmpty() || !missingTags.isEmpty() || !unknownKeys.isEmpty();
|
|
}
|
|
|
|
/**
|
|
* Performs the actual verification for the given file and collects all found issues into this
|
|
* instance's fields.
|
|
*/
|
|
private void verifyKeys() {
|
|
FileConfiguration configuration = YamlConfiguration.loadConfiguration(messagesFile);
|
|
|
|
// Check known keys (their existence + presence of all tags)
|
|
for (MessageKey messageKey : MessageKey.values()) {
|
|
final String key = messageKey.getKey();
|
|
if (configuration.isString(key)) {
|
|
checkTagsInMessage(messageKey, configuration.getString(key));
|
|
} else {
|
|
missingKeys.add(messageKey);
|
|
}
|
|
}
|
|
|
|
// Check FileConfiguration for all of its keys to find unknown keys
|
|
for (String key : configuration.getValues(true).keySet()) {
|
|
if (isNotInnerNode(key, configuration) && !messageKeyExists(key)) {
|
|
unknownKeys.add(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean isNotInnerNode(String key, FileConfiguration configuration) {
|
|
return !(configuration.get(key) instanceof MemorySection);
|
|
}
|
|
|
|
private void checkTagsInMessage(MessageKey messageKey, String message) {
|
|
for (String tag : messageKey.getTags()) {
|
|
if (!message.contains(tag)) {
|
|
missingTags.put(messageKey, tag);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean messageKeyExists(String key) {
|
|
for (MessageKey messageKey : MessageKey.values()) {
|
|
if (messageKey.getKey().equals(key)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|