diff --git a/src/main/java/org/ultramine/commands/HandlerBasedCommand.java b/src/main/java/org/ultramine/commands/HandlerBasedCommand.java index 7dba9fb..27e55b6 100644 --- a/src/main/java/org/ultramine/commands/HandlerBasedCommand.java +++ b/src/main/java/org/ultramine/commands/HandlerBasedCommand.java @@ -105,21 +105,13 @@ List result = null; Set dupChecker = null; - ArgumentsPattern.MatchResult minimumMatch = ArgumentsPattern.MatchResult.POSSIBLY; String[] tail = ArrayUtils.remove(var2, var2.length - 1); for (ArgumentsPattern argumentsPattern : argumentsPatterns) { ArgumentsPattern.MatchResult currentMatch = argumentsPattern.partialMatch(tail); - if (currentMatch.isGreaterThan(minimumMatch)) - { - minimumMatch = currentMatch; - result = null; - dupChecker = null; - } - - if (!currentMatch.isLessThan(minimumMatch)) + if (currentMatch != ArgumentsPattern.MatchResult.NOT) { List options = argumentsPattern.getCompletionOptions(var2); if (options == null || options.size() == 0) @@ -145,6 +137,9 @@ } } } + + if (currentMatch == ArgumentsPattern.MatchResult.FULLY) + break; } } return result; diff --git a/src/main/java/org/ultramine/commands/syntax/ArgumentsPattern.java b/src/main/java/org/ultramine/commands/syntax/ArgumentsPattern.java index 1afbef0..5357fbb 100644 --- a/src/main/java/org/ultramine/commands/syntax/ArgumentsPattern.java +++ b/src/main/java/org/ultramine/commands/syntax/ArgumentsPattern.java @@ -200,24 +200,5 @@ } }; - public static enum MatchResult { - FULLY(2), POSSIBLY(1), NOT(0); - - private int value; - - private MatchResult(int value) - { - this.value = value; - } - - public boolean isLessThan(MatchResult anotherResult) - { - return value < anotherResult.value; - } - - public boolean isGreaterThan(MatchResult anotherResult) - { - return value > anotherResult.value; - } - } + public static enum MatchResult { FULLY, POSSIBLY, NOT } } diff --git a/src/main/java/org/ultramine/permission/CheckResult.java b/src/main/java/org/ultramine/permission/CheckResult.java deleted file mode 100644 index f11d2e6..0000000 --- a/src/main/java/org/ultramine/permission/CheckResult.java +++ /dev/null @@ -1,29 +0,0 @@ -package org.ultramine.permission; - -public enum CheckResult -{ - TRUE, FALSE, UNRESOLVED; - - public static CheckResult fromBoolean(boolean value) - { - return value ? TRUE : FALSE; - } - - public boolean toBoolean() - { - return this == TRUE; - } - - public CheckResult invert() - { - switch (this) - { - case TRUE: - return FALSE; - case FALSE: - return TRUE; - default: - return UNRESOLVED; - } - } -} \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/ClientPermissionManager.java b/src/main/java/org/ultramine/permission/ClientPermissionManager.java deleted file mode 100644 index 23b34e2..0000000 --- a/src/main/java/org/ultramine/permission/ClientPermissionManager.java +++ /dev/null @@ -1,119 +0,0 @@ -package org.ultramine.permission; - -import java.util.HashMap; -import java.util.Map; -import java.util.Set; - -public class ClientPermissionManager implements IPermissionHandler -{ - private World global; - private PermissionRepository permissionRepository; - private Map groups; - - public ClientPermissionManager(PermissionRepository permissionRepository) - { - this.permissionRepository = permissionRepository; - this.global = new World(permissionRepository); - this.groups = new HashMap(); - } - - @Override - public boolean has(String world, String player, String permission) - { - return global.checkUserPermission(player, permission); - } - - @Override - public void add(String world, String player, String permission) - { - if (!global.contains(player)) - global.add(new User(player)); - - global.get(player).addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void addToWorld(String world, String permission) - { - global.getDefaultPermissions().addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void addToGroup(String group, String permission) - { - if (!group.startsWith("group.")) - group = "group." + group; - - if (!groups.containsKey(group)) - groups.put(group, new GroupPermission(group)); - - groups.get(group).addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void remove(String world, String player, String permission) - { - if (!global.contains(player)) - return; - - global.get(player).removePermission(permission); - } - - @Override - public void removeFromWorld(String world, String permission) - { - global.getDefaultPermissions().removePermission(permission); - } - - @Override - public void removeFromGroup(String group, String permission) - { - if (!group.startsWith("group.")) - group = "group." + group; - - if (!groups.containsKey(group)) - return; - - groups.get(group).removePermission(permission); - } - - @Override - public MetaResolver getMeta(String world, String player) - { - if (!global.contains(player)) - return MetaResolver.BLANK_RESOLVER; - - return global.get(player).getMetaResolver(); - } - - @Override - public void setMeta(String world, String player, String key, String value) - { - if (!global.contains(player)) - global.add(new User(player)); - - global.get(player).setMeta(key, value); - } - - @Override - public Set findUsersWithPermission(String world, String permission) - { - return global.getAllWithPermission(permission); - } - - @Override - public void save() - { - } - - @Override - public void reload() - { - } - - @Override - public PermissionRepository getRepository() - { - return permissionRepository; - } -} diff --git a/src/main/java/org/ultramine/permission/DummyPermission.java b/src/main/java/org/ultramine/permission/DummyPermission.java index 6e8c5a8..54ea82a 100644 --- a/src/main/java/org/ultramine/permission/DummyPermission.java +++ b/src/main/java/org/ultramine/permission/DummyPermission.java @@ -1,5 +1,9 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.CheckResult; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionResolver; + public class DummyPermission implements IPermission { private String key; @@ -16,12 +20,6 @@ } @Override - public int getPriority() - { - return Integer.MAX_VALUE; - } - - @Override public CheckResult check(String key) { if (key == null) @@ -48,13 +46,13 @@ } @Override - public void mergeTo(PermissionResolver resolver) + public void mergePermissionsTo(PermissionResolver resolver) { - resolver.merge(getKey(), true, getPriority()); + resolver.merge(getKey(), true, Integer.MAX_VALUE); } @Override - public void mergeTo(MetaResolver resolver) + public void mergeMetaTo(MetaResolver resolver) { } diff --git a/src/main/java/org/ultramine/permission/GroupPermission.java b/src/main/java/org/ultramine/permission/GroupPermission.java index 1740946..c28ff2b 100644 --- a/src/main/java/org/ultramine/permission/GroupPermission.java +++ b/src/main/java/org/ultramine/permission/GroupPermission.java @@ -1,5 +1,9 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionHolder; +import org.ultramine.permission.internal.PermissionResolver; + import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -28,25 +32,13 @@ } @Override - public CheckResult check(String key) - { - return getPermissionResolver().check(key); - } - - @Override - public String getMeta(String key) - { - return getMetaResolver().getString(key); - } - - @Override - public void mergeTo(PermissionResolver resolver) + public void mergePermissionsTo(PermissionResolver resolver) { resolver.merge(getPermissionResolver(), getPriority()); } @Override - public void mergeTo(MetaResolver resolver) + public void mergeMetaTo(MetaResolver resolver) { resolver.merge(getMetaResolver(), getPriority()); } @@ -74,6 +66,11 @@ listener.makeDirty(); } + private int getPriority() + { + return getMetaResolver().getInt("priority"); + } + @Override public int hashCode() { diff --git a/src/main/java/org/ultramine/permission/IPermission.java b/src/main/java/org/ultramine/permission/IPermission.java index 13e4e21..584daf5 100644 --- a/src/main/java/org/ultramine/permission/IPermission.java +++ b/src/main/java/org/ultramine/permission/IPermission.java @@ -1,15 +1,17 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.CheckResult; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionResolver; + public interface IPermission { public String getKey(); - public int getPriority(); - public CheckResult check(String key); public String getMeta(String key); - public void mergeTo(PermissionResolver resolver); - public void mergeTo(MetaResolver resolver); + public void mergePermissionsTo(PermissionResolver resolver); + public void mergeMetaTo(MetaResolver resolver); public void subscribe(IDirtyListener listener); public void unsubscribe(IDirtyListener listener); diff --git a/src/main/java/org/ultramine/permission/IPermissionHandler.java b/src/main/java/org/ultramine/permission/IPermissionHandler.java index d22905b..ead733f 100644 --- a/src/main/java/org/ultramine/permission/IPermissionHandler.java +++ b/src/main/java/org/ultramine/permission/IPermissionHandler.java @@ -1,5 +1,7 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.MetaResolver; + import java.util.Set; public interface IPermissionHandler diff --git a/src/main/java/org/ultramine/permission/MetaHolder.java b/src/main/java/org/ultramine/permission/MetaHolder.java deleted file mode 100644 index 99bb29a..0000000 --- a/src/main/java/org/ultramine/permission/MetaHolder.java +++ /dev/null @@ -1,51 +0,0 @@ -package org.ultramine.permission; - -import java.util.HashMap; -import java.util.Map; - -public abstract class MetaHolder -{ - protected Map innerMeta; - - public MetaHolder() - { - innerMeta = new HashMap(); - } - - public MetaHolder(Map meta) - { - setInnerMeta(meta); - } - - public void setMeta(String key, String value) - { - innerMeta.put(key, value); - } - - public void removeMeta(String key) - { - innerMeta.remove(key); - } - - public void clearMeta() - { - innerMeta.clear(); - } - - public int getPriority() - { - return getMetaResolver().getInt("priority"); - } - - public Map getInnerMeta() - { - return new HashMap(innerMeta); - } - - public void setInnerMeta(Map meta) - { - innerMeta = new HashMap(meta); - } - - public abstract MetaResolver getMetaResolver(); -} diff --git a/src/main/java/org/ultramine/permission/MetaResolver.java b/src/main/java/org/ultramine/permission/MetaResolver.java deleted file mode 100644 index d587538..0000000 --- a/src/main/java/org/ultramine/permission/MetaResolver.java +++ /dev/null @@ -1,32 +0,0 @@ -package org.ultramine.permission; - -public class MetaResolver extends Resolver -{ - public static final MetaResolver BLANK_RESOLVER = new MetaResolver(); - - public String getString(String key) - { - if (values.containsKey(key)) - return values.get(key); - else - return ""; - } - - public int getInt(String key) - { - if (values.containsKey(key)) - { - try - { - return Integer.parseInt(values.get(key)); - } - catch (Exception ignored) - { - } - } - - return 0; - } - - -} diff --git a/src/main/java/org/ultramine/permission/NegativePermission.java b/src/main/java/org/ultramine/permission/NegativePermission.java new file mode 100644 index 0000000..6042816 --- /dev/null +++ b/src/main/java/org/ultramine/permission/NegativePermission.java @@ -0,0 +1,52 @@ +package org.ultramine.permission; + +import org.ultramine.permission.internal.CheckResult; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionResolver; + +class NegativePermission extends PermissionRepository.ProxyPermission +{ + private String key; + + public NegativePermission(String key, IPermission permission) + { + super(permission); + this.key = key; + } + + @Override + public String getKey() + { + return key; + } + + @Override + public CheckResult check(String key) + { + return super.check(key).invert(); + } + + @Override + public String getMeta(String key) + { + return ""; + } + + @Override + public void mergePermissionsTo(final PermissionResolver resolver) + { + super.mergePermissionsTo(new PermissionResolver() + { + @Override + public void merge(String key, Boolean value, int priority) + { + resolver.merge(key, !value, priority); + } + }); + } + + @Override + public void mergeMetaTo(MetaResolver resolver) + { + } +} diff --git a/src/main/java/org/ultramine/permission/PermissionHolder.java b/src/main/java/org/ultramine/permission/PermissionHolder.java deleted file mode 100644 index 303eb09..0000000 --- a/src/main/java/org/ultramine/permission/PermissionHolder.java +++ /dev/null @@ -1,135 +0,0 @@ -package org.ultramine.permission; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -public class PermissionHolder extends MetaHolder implements IDirtyListener -{ - private boolean dirty; - - private Map permissions = new HashMap(); - private PermissionResolver permissionResolver = new PermissionResolver(); - private MetaResolver metaResolver = new MetaResolver(); - - public PermissionHolder() - { - super(); - this.dirty = false; - } - - public PermissionHolder(Map meta) - { - super(meta); - this.dirty = true; - } - - public PermissionResolver getPermissionResolver() - { - if (isDirty()) - calculate(); - - return permissionResolver; - } - - @Override - public MetaResolver getMetaResolver() - { - if (isDirty()) - calculate(); - - return metaResolver; - } - - public void addPermission(IPermission permission) - { - if (permissions.containsKey(permission.getKey())) - return; - - permissions.put(permission.getKey(), permission); - permission.subscribe(this); - - makeDirty(); - } - - public void removePermission(IPermission permission) - { - removePermission(permission.getKey()); - } - - public void removePermission(String key) - { - if (!permissions.containsKey(key)) - return; - - IPermission permission = permissions.remove(key); - permission.unsubscribe(this); - - makeDirty(); - } - - public void clearPermissions() - { - for (IPermission permission : permissions.values()) - permission.unsubscribe(this); - - permissions.clear(); - makeDirty(); - } - - public List getInnerPermissions() - { - return new ArrayList(permissions.keySet()); - } - - public boolean isDirty() - { - return dirty; - } - - @Override - public void makeDirty() - { - dirty = true; - } - - @Override - public void setMeta(String key, String value) - { - super.setMeta(key, value); - makeDirty(); - } - - @Override - public void removeMeta(String key) - { - super.removeMeta(key); - makeDirty(); - } - - @Override - public void clearMeta() - { - super.clearMeta(); - makeDirty(); - } - - public void calculate() - { - if (!isDirty()) - return; - dirty = false; - - permissionResolver.clear(); - metaResolver.clear(); - - for (IPermission permission : permissions.values()) - { - permission.mergeTo(getPermissionResolver()); - permission.mergeTo(getMetaResolver()); - } - - metaResolver.merge(innerMeta, Integer.MAX_VALUE); - } -} \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/PermissionRepository.java b/src/main/java/org/ultramine/permission/PermissionRepository.java index 27deaf1..459d7ff 100644 --- a/src/main/java/org/ultramine/permission/PermissionRepository.java +++ b/src/main/java/org/ultramine/permission/PermissionRepository.java @@ -1,5 +1,9 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.CheckResult; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionResolver; + import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -32,7 +36,7 @@ { if (key.startsWith("^")) { - proxyPermissions.put(key, new NegativePermission(key)); + proxyPermissions.put(key, new NegativePermission(key, getPermission(key.substring(1)))); registeredPermissions.add(key); } else @@ -80,7 +84,6 @@ { this.wrappedPermission = permission; this.isDummy = false; - listeners = new ArrayList(); } @Override @@ -94,10 +97,9 @@ return wrappedPermission; } - @Override - public int getPriority() + public boolean isDummy() { - return wrappedPermission.getPriority(); + return isDummy; } @Override @@ -113,15 +115,15 @@ } @Override - public void mergeTo(PermissionResolver resolver) + public void mergePermissionsTo(PermissionResolver resolver) { - wrappedPermission.mergeTo(resolver); + wrappedPermission.mergePermissionsTo(resolver); } @Override - public void mergeTo(MetaResolver resolver) + public void mergeMetaTo(MetaResolver resolver) { - wrappedPermission.mergeTo(resolver); + wrappedPermission.mergeMetaTo(resolver); } @Override @@ -172,33 +174,4 @@ return wrappedPermission.toString(); } } - - private class NegativePermission extends ProxyPermission - { - private String key; - - public NegativePermission(String key) - { - super(getPermission(key.substring(1))); - this.key = key; - } - - @Override - public String getKey() - { - return key; - } - - @Override - public CheckResult check(String key) - { - return super.check(key).invert(); - } - - @Override - public String getMeta(String key) - { - return ""; - } - } } \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/PermissionResolver.java b/src/main/java/org/ultramine/permission/PermissionResolver.java deleted file mode 100644 index 3607453..0000000 --- a/src/main/java/org/ultramine/permission/PermissionResolver.java +++ /dev/null @@ -1,50 +0,0 @@ -package org.ultramine.permission; - -import java.util.Map; - -public class PermissionResolver extends Resolver -{ - public static PermissionResolver createInverted(PermissionResolver anotherResolver) - { - PermissionResolver resolver = new PermissionResolver(); - for (Map.Entry entry : anotherResolver.values.entrySet()) - { - resolver.values.put(entry.getKey(), !entry.getValue()); - resolver.priorities.put(entry.getKey(), anotherResolver.priorities.get(entry.getKey())); - } - return resolver; - } - - public static PermissionResolver createForKey(String key, int priority) - { - PermissionResolver resolver = new PermissionResolver(); - resolver.values.put(key, true); - resolver.priorities.put(key, priority); - return resolver; - } - - public CheckResult check(String key) - { - if (key == null) - return CheckResult.UNRESOLVED; - - key = key.toLowerCase(); - if (values.containsKey(key)) - return CheckResult.fromBoolean(values.get(key)); - - int index = key.lastIndexOf('.'); - while (index >= 0) - { - key = key.substring(0, index); - String wildcard = key + ".*"; - if (values.containsKey(wildcard)) - return CheckResult.fromBoolean(values.get(wildcard)); - - index = key.lastIndexOf('.'); - } - if (values.containsKey("*")) - return CheckResult.fromBoolean(values.get("*")); - - return CheckResult.UNRESOLVED; - } -} diff --git a/src/main/java/org/ultramine/permission/Resolver.java b/src/main/java/org/ultramine/permission/Resolver.java deleted file mode 100644 index 78a917a..0000000 --- a/src/main/java/org/ultramine/permission/Resolver.java +++ /dev/null @@ -1,46 +0,0 @@ -package org.ultramine.permission; - -import gnu.trove.map.hash.TObjectIntHashMap; - -import java.util.HashMap; -import java.util.Map; - -public class Resolver -{ - protected Map values; - protected TObjectIntHashMap priorities; - - public Resolver() - { - values = new HashMap(); - priorities = new TObjectIntHashMap(); - } - - public void clear() - { - values.clear(); - priorities.clear(); - } - - public void merge(Resolver anotherResolver, int priority) - { - if (anotherResolver != null) - merge(anotherResolver.values, priority); - } - - public void merge(Map newValues, int priority) - { - for (Map.Entry entry : newValues.entrySet()) - merge(entry.getKey(), entry.getValue(), priority); - - } - - public void merge(String key, T value, int priority) - { - if (!priorities.containsKey(key) || priorities.get(key) < priority) - { - values.put(key, value); - priorities.put(key, priority); - } - } -} diff --git a/src/main/java/org/ultramine/permission/ServerPermissionManager.java b/src/main/java/org/ultramine/permission/ServerPermissionManager.java deleted file mode 100644 index 9ab09f9..0000000 --- a/src/main/java/org/ultramine/permission/ServerPermissionManager.java +++ /dev/null @@ -1,259 +0,0 @@ -package org.ultramine.permission; - -import org.ultramine.server.util.YamlConfigProvider; - -import java.io.File; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; - -public class ServerPermissionManager implements IPermissionHandler -{ - private final static String GLOBAL_WORLD = "global"; - private final static String GROUPS_CONFIG = "groups.yml"; - - private File configDir; - private Map worlds; - private PermissionRepository permissionRepository; - private Map groups; - - public ServerPermissionManager(File configDir, PermissionRepository permissionRepository) - { - this.configDir = new File(configDir, "permissions"); - if (!this.configDir.exists()) - this.configDir.mkdir(); - - this.permissionRepository = permissionRepository; - this.worlds = new HashMap(); - this.groups = new HashMap(); - reloadGroups(); - reloadWorld(GLOBAL_WORLD); - } - - - @Override - public boolean has(String world, String player, String permission) - { - if (!worlds.containsKey(world)) - return getGlobal().checkUserPermission(player, permission); - - return getWorld(world).checkUserPermission(player, permission); - } - - @Override - public void add(String world, String player, String permission) - { - if (!worlds.containsKey(world)) - reloadWorld(world); - - World worldContainer = getWorld(world); - if (!worldContainer.contains(player)) - worldContainer.add(new User(player)); - - worldContainer.get(player).addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void addToWorld(String world, String permission) - { - if (!worlds.containsKey(world)) - reloadWorld(world); - - getWorld(world).getDefaultPermissions().addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void addToGroup(String group, String permission) - { - if (!group.startsWith("group.")) - group = "group." + group; - - if (!groups.containsKey(group)) - groups.put(group, new GroupPermission(group)); - - groups.get(group).addPermission(permissionRepository.getPermission(permission)); - } - - @Override - public void remove(String world, String player, String permission) - { - if (!worlds.containsKey(world)) - return; - - World worldContainer = getWorld(world); - if (!worldContainer.contains(player)) - return; - - worldContainer.get(player).removePermission(permission); - } - - @Override - public void removeFromWorld(String world, String permission) - { - if (!worlds.containsKey(world)) - return; - - getWorld(world).getDefaultPermissions().removePermission(permission); - } - - @Override - public void removeFromGroup(String group, String permission) - { - if (!group.startsWith("group.")) - group = "group." + group; - - if (!groups.containsKey(group)) - return; - - groups.get(group).removePermission(permission); - } - - @Override - public MetaResolver getMeta(String world, String player) - { - if (!worlds.containsKey(world)) - return MetaResolver.BLANK_RESOLVER; - - World worldContainer = getWorld(world); - if (!worldContainer.contains(player)) - return MetaResolver.BLANK_RESOLVER; - - return worldContainer.get(player).getMetaResolver(); - } - - @Override - public void setMeta(String world, String player, String key, String value) - { - if (!worlds.containsKey(world)) - reloadWorld(world); - - World worldContainer = getWorld(world); - if (!worldContainer.contains(player)) - worldContainer.add(new User(player)); - - worldContainer.get(player).setMeta(key, value); - } - - @Override - public Set findUsersWithPermission(String world, String permission) - { - if (!worlds.containsKey(world)) - return getGlobal().getAllWithPermission(permission); - - return getWorld(world).getAllWithPermission(permission); - } - - @Override - public void save() - { - saveGroups(); - for (String world : worlds.keySet()) - saveWorld(world); - } - - @Override - public void reload() - { - reloadGroups(); - for (String world : worlds.keySet()) - reloadWorld(world); - } - - @Override - public PermissionRepository getRepository() - { - return permissionRepository; - } - - public void reloadWorld(String name) - { - World.WorldData data = YamlConfigProvider.getOrCreateConfig(worldFile(name), World.WorldData.class); - if (!worlds.containsKey(name)) - worlds.put(name, new World(permissionRepository)); - - worlds.get(name).load(data); - - if (!name.equals(GLOBAL_WORLD)) - worlds.get(name).setParentContainer(getGlobal()); - - } - - public void saveWorld(String name) - { - if (!worlds.containsKey(name)) - return; - - YamlConfigProvider.saveConfig(worldFile(name), worlds.get(name).save()); - } - - public void reloadGroups() - { - for (GroupPermission group : groups.values()) - { - group.clearPermissions(); - group.clearMeta(); - } - - GroupData data = YamlConfigProvider.getOrCreateConfig(groupsFile(), GroupData.class); - if (data == null || data.groups == null) - return; - - for (Map.Entry groupData : data.groups.entrySet()) - { - GroupPermission group; - String groupKey = groupData.getKey(); - if (!groupKey.startsWith("group.")) - groupKey = "group." + groupKey; - - if (!groups.containsKey(groupKey)) - { - group = new GroupPermission(groupKey, groupData.getValue().meta); - permissionRepository.registerPermission(group); - groups.put(groupKey, group); - } - else - { - group = groups.get(groupKey); - group.setInnerMeta(groupData.getValue().meta); - } - - for (String pKey : groupData.getValue().permissions) - group.addPermission(permissionRepository.getPermission(pKey)); - } - } - - public void saveGroups() - { - GroupData data = new GroupData(); - - for (Map.Entry group : groups.entrySet()) - data.groups.put(group.getKey(), new World.HolderData(group.getValue())); - - YamlConfigProvider.saveConfig(groupsFile(), data); - } - - public World getWorld(String name) - { - return worlds.get(name); - } - - public World getGlobal() - { - return getWorld(GLOBAL_WORLD); - } - - private File worldFile(String name) - { - return new File(configDir, "users-" + name + ".yml"); - } - - private File groupsFile() - { - return new File(configDir, GROUPS_CONFIG); - } - - public static class GroupData - { - public Map groups = new HashMap(); - } -} diff --git a/src/main/java/org/ultramine/permission/User.java b/src/main/java/org/ultramine/permission/User.java index 193ac5d..80c9f4b 100644 --- a/src/main/java/org/ultramine/permission/User.java +++ b/src/main/java/org/ultramine/permission/User.java @@ -1,5 +1,7 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.PermissionHolder; + import java.util.Map; public class User extends PermissionHolder @@ -22,10 +24,4 @@ { return name; } - - @Override - public int getPriority() - { - return getMetaResolver().getInt("priority"); - } } \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/UserContainer.java b/src/main/java/org/ultramine/permission/UserContainer.java deleted file mode 100644 index 8a5735e..0000000 --- a/src/main/java/org/ultramine/permission/UserContainer.java +++ /dev/null @@ -1,97 +0,0 @@ -package org.ultramine.permission; - -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -public class UserContainer -{ - protected Map users; - protected UserContainer parentContainer; - - public UserContainer() - { - users = new HashMap(); - } - - public UserContainer(UserContainer parentContainer) - { - this(); - this.parentContainer = parentContainer; - } - - public final boolean checkUserPermission(String userName, String permissionKey) - { - return check(userName, permissionKey) == CheckResult.TRUE; - } - - protected CheckResult check(String userName, String permissionKey) - { - userName = userName.toLowerCase(); - CheckResult result = CheckResult.UNRESOLVED; - - if (parentContainer != null) - result = parentContainer.check(userName, permissionKey); - - if (result == CheckResult.UNRESOLVED && contains(userName)) - result = get(userName).getPermissionResolver().check(permissionKey); - - return result; - } - - public T get(String name) - { - return users.get(name.toLowerCase()); - } - - public Set getAllWithPermission(String permission) - { - Set result; - if (parentContainer != null) - result = parentContainer.getAllWithPermission(permission); - else - result = new HashSet(); - - for (User user : users.values()) - { - if (user.getPermissionResolver().check(permission) == CheckResult.TRUE) - result.add(user.getName()); - } - - return result; - } - - public void add(T user) - { - if (users.containsKey(user.getName())) - return; - - users.put(user.getName(), user); - } - - public void remove(String name) - { - users.remove(name.toLowerCase()); - } - - public void remove(User user) - { - remove(user.getName()); - } - - public void clear() - { - users.clear(); - } - - public boolean contains(String name) - { - return users.containsKey(name); - } - - public boolean contains(User user) - { - return contains(user.getName()); - } -} diff --git a/src/main/java/org/ultramine/permission/World.java b/src/main/java/org/ultramine/permission/World.java index 20e65db..bd1d765 100644 --- a/src/main/java/org/ultramine/permission/World.java +++ b/src/main/java/org/ultramine/permission/World.java @@ -1,5 +1,9 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.CheckResult; +import org.ultramine.permission.internal.PermissionHolder; +import org.ultramine.permission.internal.UserContainer; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -70,7 +74,7 @@ CheckResult result = super.check(userName, permissionKey); if (result == CheckResult.UNRESOLVED) - result = defaultPermissions.getPermissionResolver().check(permissionKey); + result = defaultPermissions.check(permissionKey); return result; } diff --git a/src/main/java/org/ultramine/permission/internal/CheckResult.java b/src/main/java/org/ultramine/permission/internal/CheckResult.java new file mode 100644 index 0000000..b25f6f9 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/CheckResult.java @@ -0,0 +1,29 @@ +package org.ultramine.permission.internal; + +public enum CheckResult +{ + TRUE, FALSE, UNRESOLVED; + + public static CheckResult fromBoolean(boolean value) + { + return value ? TRUE : FALSE; + } + + public boolean toBoolean() + { + return this == TRUE; + } + + public CheckResult invert() + { + switch (this) + { + case TRUE: + return FALSE; + case FALSE: + return TRUE; + default: + return UNRESOLVED; + } + } +} \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java b/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java new file mode 100644 index 0000000..c6dc538 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java @@ -0,0 +1,121 @@ +package org.ultramine.permission.internal; + +import org.ultramine.permission.*; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class ClientPermissionManager implements IPermissionHandler +{ + private World global; + private PermissionRepository permissionRepository; + private Map groups; + + public ClientPermissionManager(PermissionRepository permissionRepository) + { + this.permissionRepository = permissionRepository; + this.global = new World(permissionRepository); + this.groups = new HashMap(); + } + + @Override + public boolean has(String world, String player, String permission) + { + return global.checkUserPermission(player, permission); + } + + @Override + public void add(String world, String player, String permission) + { + if (!global.contains(player)) + global.add(new User(player)); + + global.get(player).addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void addToWorld(String world, String permission) + { + global.getDefaultPermissions().addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void addToGroup(String group, String permission) + { + if (!group.startsWith("group.")) + group = "group." + group; + + if (!groups.containsKey(group)) + groups.put(group, new GroupPermission(group)); + + groups.get(group).addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void remove(String world, String player, String permission) + { + if (!global.contains(player)) + return; + + global.get(player).removePermission(permission); + } + + @Override + public void removeFromWorld(String world, String permission) + { + global.getDefaultPermissions().removePermission(permission); + } + + @Override + public void removeFromGroup(String group, String permission) + { + if (!group.startsWith("group.")) + group = "group." + group; + + if (!groups.containsKey(group)) + return; + + groups.get(group).removePermission(permission); + } + + @Override + public MetaResolver getMeta(String world, String player) + { + if (!global.contains(player)) + return MetaResolver.BLANK_RESOLVER; + + return global.get(player).getMetaResolver(); + } + + @Override + public void setMeta(String world, String player, String key, String value) + { + if (!global.contains(player)) + global.add(new User(player)); + + global.get(player).setMeta(key, value); + } + + @Override + public Set findUsersWithPermission(String world, String permission) + { + return global.getAllWithPermission(permission); + } + + @Override + public void save() + { + } + + @Override + public void reload() + { + } + + @Override + public PermissionRepository getRepository() + { + return permissionRepository; + } +} diff --git a/src/main/java/org/ultramine/permission/internal/MetaHolder.java b/src/main/java/org/ultramine/permission/internal/MetaHolder.java new file mode 100644 index 0000000..7c2dc6d --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/MetaHolder.java @@ -0,0 +1,56 @@ +package org.ultramine.permission.internal; + +import java.util.HashMap; +import java.util.Map; + +public abstract class MetaHolder +{ + private Map innerMeta; + + public MetaHolder() + { + innerMeta = new HashMap(); + } + + public MetaHolder(Map meta) + { + setInnerMeta(meta); + } + + public String getMeta(String key) + { + return getMetaResolver().getString(key); + } + + public void setMeta(String key, String value) + { + innerMeta.put(key, value); + } + + public void removeMeta(String key) + { + innerMeta.remove(key); + } + + public void clearMeta() + { + innerMeta.clear(); + } + + public Map getInnerMeta() + { + return new HashMap(innerMeta); + } + + public void setInnerMeta(Map meta) + { + innerMeta = new HashMap(meta); + } + + protected abstract MetaResolver getMetaResolver(); + + protected void mergeInnerMeta() + { + getMetaResolver().merge(innerMeta, Integer.MAX_VALUE); + } +} diff --git a/src/main/java/org/ultramine/permission/internal/MetaResolver.java b/src/main/java/org/ultramine/permission/internal/MetaResolver.java new file mode 100644 index 0000000..76baea7 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/MetaResolver.java @@ -0,0 +1,35 @@ +package org.ultramine.permission.internal; + +public class MetaResolver extends Resolver +{ + public static final MetaResolver BLANK_RESOLVER = new MetaResolver(); + + public MetaResolver() + { + super(); + } + + public String getString(String key) + { + if (values.containsKey(key)) + return values.get(key); + else + return ""; + } + + public int getInt(String key) + { + if (values.containsKey(key)) + { + try + { + return Integer.parseInt(values.get(key)); + } + catch (Exception ignored) + { + } + } + + return 0; + } +} diff --git a/src/main/java/org/ultramine/permission/internal/PermissionHolder.java b/src/main/java/org/ultramine/permission/internal/PermissionHolder.java new file mode 100644 index 0000000..2bf7aae --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/PermissionHolder.java @@ -0,0 +1,143 @@ +package org.ultramine.permission.internal; + +import org.ultramine.permission.IDirtyListener; +import org.ultramine.permission.IPermission; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class PermissionHolder extends MetaHolder implements IDirtyListener +{ + private boolean dirty; + + private Map permissions = new HashMap(); + private PermissionResolver permissionResolver = new PermissionResolver(); + private MetaResolver metaResolver = new MetaResolver(); + + public PermissionHolder() + { + super(); + this.dirty = false; + } + + public PermissionHolder(Map meta) + { + super(meta); + this.dirty = true; + } + + public CheckResult check(String key) + { + return getPermissionResolver().check(key); + } + + public void addPermission(IPermission permission) + { + if (permissions.containsKey(permission.getKey())) + return; + + permissions.put(permission.getKey(), permission); + permission.subscribe(this); + + makeDirty(); + } + + public void removePermission(IPermission permission) + { + removePermission(permission.getKey()); + } + + public void removePermission(String key) + { + if (!permissions.containsKey(key)) + return; + + IPermission permission = permissions.remove(key); + permission.unsubscribe(this); + + makeDirty(); + } + + public void clearPermissions() + { + for (IPermission permission : permissions.values()) + permission.unsubscribe(this); + + permissions.clear(); + makeDirty(); + } + + public List getInnerPermissions() + { + return new ArrayList(permissions.keySet()); + } + + public boolean isDirty() + { + return dirty; + } + + @Override + public void makeDirty() + { + dirty = true; + } + + @Override + public void setMeta(String key, String value) + { + super.setMeta(key, value); + makeDirty(); + } + + @Override + public void removeMeta(String key) + { + super.removeMeta(key); + makeDirty(); + } + + @Override + public void clearMeta() + { + super.clearMeta(); + makeDirty(); + } + + public void calculate() + { + if (!isDirty()) + return; + dirty = false; + + permissionResolver.clear(); + metaResolver.clear(); + + for (IPermission permission : permissions.values()) + { + permission.mergePermissionsTo(permissionResolver); + permission.mergeMetaTo(metaResolver); + } + + mergeInnerMeta(); + } + + protected PermissionResolver getPermissionResolver() + { + if (isDirty()) + calculate(); + + return permissionResolver; + } + + @Override + protected MetaResolver getMetaResolver() + { + if (isDirty()) + calculate(); + + return metaResolver; + } +} \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/internal/PermissionResolver.java b/src/main/java/org/ultramine/permission/internal/PermissionResolver.java new file mode 100644 index 0000000..93f247a --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/PermissionResolver.java @@ -0,0 +1,55 @@ +package org.ultramine.permission.internal; + +import java.util.Map; + +public class PermissionResolver extends Resolver +{ + public PermissionResolver() + { + super(); + } + + public static PermissionResolver createInverted(PermissionResolver anotherResolver) + { + PermissionResolver resolver = new PermissionResolver(); + for (Map.Entry entry : anotherResolver.values.entrySet()) + { + resolver.values.put(entry.getKey(), !entry.getValue()); + resolver.priorities.put(entry.getKey(), anotherResolver.priorities.get(entry.getKey())); + } + return resolver; + } + + public static PermissionResolver createForKey(String key, int priority) + { + PermissionResolver resolver = new PermissionResolver(); + resolver.values.put(key, true); + resolver.priorities.put(key, priority); + return resolver; + } + + public CheckResult check(String key) + { + if (key == null) + return CheckResult.UNRESOLVED; + + key = key.toLowerCase(); + if (values.containsKey(key)) + return CheckResult.fromBoolean(values.get(key)); + + int index = key.lastIndexOf('.'); + while (index >= 0) + { + key = key.substring(0, index); + String wildcard = key + ".*"; + if (values.containsKey(wildcard)) + return CheckResult.fromBoolean(values.get(wildcard)); + + index = key.lastIndexOf('.'); + } + if (values.containsKey("*")) + return CheckResult.fromBoolean(values.get("*")); + + return CheckResult.UNRESOLVED; + } +} diff --git a/src/main/java/org/ultramine/permission/internal/Resolver.java b/src/main/java/org/ultramine/permission/internal/Resolver.java new file mode 100644 index 0000000..0b4b5b4 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/Resolver.java @@ -0,0 +1,46 @@ +package org.ultramine.permission.internal; + +import gnu.trove.map.hash.TObjectIntHashMap; + +import java.util.HashMap; +import java.util.Map; + +public class Resolver +{ + protected Map values; + protected TObjectIntHashMap priorities; + + public Resolver() + { + values = new HashMap(); + priorities = new TObjectIntHashMap(); + } + + public void clear() + { + values.clear(); + priorities.clear(); + } + + public final void merge(Resolver anotherResolver, int priority) + { + if (anotherResolver != null) + merge(anotherResolver.values, priority); + } + + public final void merge(Map newValues, int priority) + { + for (Map.Entry entry : newValues.entrySet()) + merge(entry.getKey(), entry.getValue(), priority); + + } + + public void merge(String key, T value, int priority) + { + if (!priorities.containsKey(key) || priorities.get(key) < priority) + { + values.put(key, value); + priorities.put(key, priority); + } + } +} diff --git a/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java b/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java new file mode 100644 index 0000000..628539a --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java @@ -0,0 +1,260 @@ +package org.ultramine.permission.internal; + +import org.ultramine.permission.*; +import org.ultramine.server.util.YamlConfigProvider; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class ServerPermissionManager implements IPermissionHandler +{ + private final static String GLOBAL_WORLD = "global"; + private final static String GROUPS_CONFIG = "groups.yml"; + + private File configDir; + private Map worlds; + private PermissionRepository permissionRepository; + private Map groups; + + public ServerPermissionManager(File configDir, PermissionRepository permissionRepository) + { + this.configDir = new File(configDir, "permissions"); + if (!this.configDir.exists()) + this.configDir.mkdir(); + + this.permissionRepository = permissionRepository; + this.worlds = new HashMap(); + this.groups = new HashMap(); + reloadGroups(); + reloadWorld(GLOBAL_WORLD); + } + + + @Override + public boolean has(String world, String player, String permission) + { + if (!worlds.containsKey(world)) + return getGlobal().checkUserPermission(player, permission); + + return getWorld(world).checkUserPermission(player, permission); + } + + @Override + public void add(String world, String player, String permission) + { + if (!worlds.containsKey(world)) + reloadWorld(world); + + World worldContainer = getWorld(world); + if (!worldContainer.contains(player)) + worldContainer.add(new User(player)); + + worldContainer.get(player).addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void addToWorld(String world, String permission) + { + if (!worlds.containsKey(world)) + reloadWorld(world); + + getWorld(world).getDefaultPermissions().addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void addToGroup(String group, String permission) + { + if (!group.startsWith("group.")) + group = "group." + group; + + if (!groups.containsKey(group)) + groups.put(group, new GroupPermission(group)); + + groups.get(group).addPermission(permissionRepository.getPermission(permission)); + } + + @Override + public void remove(String world, String player, String permission) + { + if (!worlds.containsKey(world)) + return; + + World worldContainer = getWorld(world); + if (!worldContainer.contains(player)) + return; + + worldContainer.get(player).removePermission(permission); + } + + @Override + public void removeFromWorld(String world, String permission) + { + if (!worlds.containsKey(world)) + return; + + getWorld(world).getDefaultPermissions().removePermission(permission); + } + + @Override + public void removeFromGroup(String group, String permission) + { + if (!group.startsWith("group.")) + group = "group." + group; + + if (!groups.containsKey(group)) + return; + + groups.get(group).removePermission(permission); + } + + @Override + public MetaResolver getMeta(String world, String player) + { + if (!worlds.containsKey(world)) + return MetaResolver.BLANK_RESOLVER; + + World worldContainer = getWorld(world); + if (!worldContainer.contains(player)) + return MetaResolver.BLANK_RESOLVER; + + return worldContainer.get(player).getMetaResolver(); + } + + @Override + public void setMeta(String world, String player, String key, String value) + { + if (!worlds.containsKey(world)) + reloadWorld(world); + + World worldContainer = getWorld(world); + if (!worldContainer.contains(player)) + worldContainer.add(new User(player)); + + worldContainer.get(player).setMeta(key, value); + } + + @Override + public Set findUsersWithPermission(String world, String permission) + { + if (!worlds.containsKey(world)) + return getGlobal().getAllWithPermission(permission); + + return getWorld(world).getAllWithPermission(permission); + } + + @Override + public void save() + { + saveGroups(); + for (String world : worlds.keySet()) + saveWorld(world); + } + + @Override + public void reload() + { + reloadGroups(); + for (String world : worlds.keySet()) + reloadWorld(world); + } + + @Override + public PermissionRepository getRepository() + { + return permissionRepository; + } + + public void reloadWorld(String name) + { + World.WorldData data = YamlConfigProvider.getOrCreateConfig(worldFile(name), World.WorldData.class); + if (!worlds.containsKey(name)) + worlds.put(name, new World(permissionRepository)); + + worlds.get(name).load(data); + + if (!name.equals(GLOBAL_WORLD)) + worlds.get(name).setParentContainer(getGlobal()); + + } + + public void saveWorld(String name) + { + if (!worlds.containsKey(name)) + return; + + YamlConfigProvider.saveConfig(worldFile(name), worlds.get(name).save()); + } + + public void reloadGroups() + { + for (GroupPermission group : groups.values()) + { + group.clearPermissions(); + group.clearMeta(); + } + + GroupData data = YamlConfigProvider.getOrCreateConfig(groupsFile(), GroupData.class); + if (data == null || data.groups == null) + return; + + for (Map.Entry groupData : data.groups.entrySet()) + { + GroupPermission group; + String groupKey = groupData.getKey(); + if (!groupKey.startsWith("group.")) + groupKey = "group." + groupKey; + + if (!groups.containsKey(groupKey)) + { + group = new GroupPermission(groupKey, groupData.getValue().meta); + permissionRepository.registerPermission(group); + groups.put(groupKey, group); + } + else + { + group = groups.get(groupKey); + group.setInnerMeta(groupData.getValue().meta); + } + + for (String pKey : groupData.getValue().permissions) + group.addPermission(permissionRepository.getPermission(pKey)); + } + } + + public void saveGroups() + { + GroupData data = new GroupData(); + + for (Map.Entry group : groups.entrySet()) + data.groups.put(group.getKey(), new World.HolderData(group.getValue())); + + YamlConfigProvider.saveConfig(groupsFile(), data); + } + + public World getWorld(String name) + { + return worlds.get(name); + } + + public World getGlobal() + { + return getWorld(GLOBAL_WORLD); + } + + private File worldFile(String name) + { + return new File(configDir, "users-" + name + ".yml"); + } + + private File groupsFile() + { + return new File(configDir, GROUPS_CONFIG); + } + + public static class GroupData + { + public Map groups = new HashMap(); + } +} diff --git a/src/main/java/org/ultramine/permission/internal/UserContainer.java b/src/main/java/org/ultramine/permission/internal/UserContainer.java new file mode 100644 index 0000000..85105c6 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/UserContainer.java @@ -0,0 +1,99 @@ +package org.ultramine.permission.internal; + +import org.ultramine.permission.User; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +public class UserContainer +{ + protected Map users; + protected UserContainer parentContainer; + + public UserContainer() + { + users = new HashMap(); + } + + public UserContainer(UserContainer parentContainer) + { + this(); + this.parentContainer = parentContainer; + } + + public final boolean checkUserPermission(String userName, String permissionKey) + { + return check(userName, permissionKey) == CheckResult.TRUE; + } + + protected CheckResult check(String userName, String permissionKey) + { + userName = userName.toLowerCase(); + CheckResult result = CheckResult.UNRESOLVED; + + if (parentContainer != null) + result = parentContainer.check(userName, permissionKey); + + if (result == CheckResult.UNRESOLVED && contains(userName)) + result = get(userName).check(permissionKey); + + return result; + } + + public T get(String name) + { + return users.get(name.toLowerCase()); + } + + public Set getAllWithPermission(String permission) + { + Set result; + if (parentContainer != null) + result = parentContainer.getAllWithPermission(permission); + else + result = new HashSet(); + + for (User user : users.values()) + { + if (user.check(permission) == CheckResult.TRUE) + result.add(user.getName()); + } + + return result; + } + + public void add(T user) + { + if (users.containsKey(user.getName())) + return; + + users.put(user.getName(), user); + } + + public void remove(String name) + { + users.remove(name.toLowerCase()); + } + + public void remove(User user) + { + remove(user.getName()); + } + + public void clear() + { + users.clear(); + } + + public boolean contains(String name) + { + return users.containsKey(name); + } + + public boolean contains(User user) + { + return contains(user.getName()); + } +} diff --git a/src/main/java/org/ultramine/server/PermissionHandler.java b/src/main/java/org/ultramine/server/PermissionHandler.java index b0e18e0..b742370 100644 --- a/src/main/java/org/ultramine/server/PermissionHandler.java +++ b/src/main/java/org/ultramine/server/PermissionHandler.java @@ -1,8 +1,13 @@ package org.ultramine.server; import net.minecraft.command.ICommandSender; -import org.ultramine.permission.*; import org.ultramine.permission.DummyPermission; +import org.ultramine.permission.IPermission; +import org.ultramine.permission.IPermissionHandler; +import org.ultramine.permission.PermissionRepository; +import org.ultramine.permission.internal.ClientPermissionManager; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.ServerPermissionManager; import java.util.Set; diff --git a/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy b/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy index cccb648..047e767 100644 --- a/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy +++ b/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy @@ -22,8 +22,8 @@ !group2.isDirty() and: "Both groups have own meta" - group1.getMetaResolver().getString("m1") - group2.getMetaResolver().getString("m2") + group1.getMeta("m1") + group2.getMeta("m2") } def "Test dirty notification"() { @@ -43,44 +43,34 @@ def "Test subscribing to permission changes"() { setup: - def sPerm = Mock(IPermission) { getKey() >> "p" } - def cPerm = Mock(IPermission) { getKey() >> "c" } + def permission = Mock(IPermission) { getKey() >> "c" } def group = new GroupPermission("group.test") - when: "Add permissions to group" - group.addPermission(sPerm) - group.addPermission(cPerm) + when: "Add permission to group" + group.addPermission(permission) - then: "Group subscribes to IChangeablePermission" - 1 * cPerm.subscribe(group) - 0 * sPerm.subscribe(_) + then: "Group subscribes to permission" + 1 * permission.subscribe(group) - when: "Remove permissions from group" - group.removePermission(sPerm) - group.removePermission(cPerm) + when: "Remove permission from group" + group.removePermission(permission) - then: "Group unsubscribes to IChangeablePermission" - 1 * cPerm.unsubscribe(group) - 0 * sPerm.unsubscribe(_) + then: "Group unsubscribes to permission" + 1 * permission.unsubscribe(group) } def "Test meta parsing"() { setup: def group = new GroupPermission("group.test", [ - name: "Test1", - description: "Test2", - priority: 200, + priority: "200", perfix: "Test3" ]) expect: group.getKey() == "group.test" - group.getName() == "Test1" - group.getDescription() == "Test2" group.getPriority() == 200 - group.getMetaResolver().getString("perfix") == "Test3" - group.getMetaResolver().getString("asd") == "" - group.getMetaResolver().getInt("dsa") == 0 + group.getMeta("perfix") == "Test3" + group.getMeta("asd") == "" } def "Test blank group"() { @@ -89,8 +79,6 @@ expect: group.getKey() == "group.test" - group.getName() == "group.test" - group.getDescription() == "" group.getPriority() == 0 } } diff --git a/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy b/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy index c6de2c1..ac0f759 100644 --- a/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy +++ b/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy @@ -1,6 +1,9 @@ package org.ultramine.permission -import static CheckResult.* +import org.ultramine.permission.internal.MetaResolver +import org.ultramine.permission.internal.PermissionResolver + +import static org.ultramine.permission.internal.CheckResult.* import spock.lang.Specification /** @@ -12,69 +15,25 @@ setup: IPermission permission = Mock(IPermission) { getKey() >> "test.key" - getName() >> "Test Name" - getDescription() >> "Test Description" - getPriority() >> 100 - getPermissionResolver() >> PermissionResolver.createForKey("test.key", 1) + getMeta("aza") >> "aza" + check("aza") >> TRUE } when: "Create new NegativePermission" - def perm = new PermissionRepository.NegativePermission(permission) + def perm = new NegativePermission("^test.key", permission) then: "PermissionResolver was inverted" perm.getKey() == "^test.key" - perm.getName() == "NOT: Test Name" - perm.getDescription() == "NOT: Test Description" - perm.getPriority() == 100 - perm.getPermissionResolver().check("test.key") == FALSE + perm.getMeta("aza") == "" + perm.check("aza") == FALSE } - def "Test subscribe/unsubscribe IPermission"() { + def "Test subscribe/unsubscribe permission"() { setup: IPermission permission = Mock(IPermission) def listener = Mock(IDirtyListener) - def perm = new PermissionRepository.NegativePermission(permission) - - when: "Try to subscribe/unsubscribe listener" - perm.subscribe(listener) - perm.unsubscribe(listener) - - then: "No interaction were done" - 0 * permission._ - 0 * listener._ - } - - def "Test wrap IChangeablePermission"() { - setup: "Create new NegativePermission" - IPermission permission = Mock(IPermission) { - getKey() >> "test.key" - getName() >> "Test Name" - getDescription() >> "Test Description" - getPriority() >> 100 - getPermissionResolver() >> PermissionResolver.createForKey("test.key", 1) - } - - when: "Create new NegativePermission" - def perm = new PermissionRepository.NegativePermission(permission) - - then: "PermissionResolver was inverted" - perm.getKey() == "^test.key" - perm.getName() == "NOT: Test Name" - perm.getDescription() == "NOT: Test Description" - perm.getPriority() == 100 - perm.getPermissionResolver().check("test.key") == FALSE - - and: "Subscribed to permission" - 1 * permission.subscribe(_) - } - - def "Test subscribe/unsubscribe IChangeablePermission"() { - setup: - IPermission permission = Mock(IPermission) - - def listener = Mock(IDirtyListener) - def perm = new PermissionRepository.NegativePermission(permission) + def perm = new NegativePermission("key", permission) when: "Try to subscribe/unsubscribe listener" perm.subscribe(listener) @@ -86,26 +45,13 @@ 0 * listener._ } - def "Test blank description"() { - setup: "Permission with blank description" - IPermission permission = Mock(IPermission) { - getDescription() >> "" - } - - when: "Create new NegativePermission" - def perm = new PermissionRepository.NegativePermission(permission) - - then: "Description is blank" - perm.getDescription() == "" - } - def "Test blank meta"() { when: "Create new NegativePermission" - def perm = new PermissionRepository.NegativePermission(Mock(IPermission)) + def perm = new NegativePermission("per", Mock(IPermission)) then: "Description is blank" - perm.getMeta() == MetaResolver.BLANK_RESOLVER + perm.getMeta("za") == "" } def "Test integration with group permission"() { @@ -114,16 +60,16 @@ group.addPermission(new DummyPermission("p1")) when: "Create negative permission" - def perm = new PermissionRepository.NegativePermission(group) + def perm = new NegativePermission("key", group) then: "Negative permission contains group permissions" - perm.getPermissionResolver().check("p1") == FALSE + perm.check("p1") == FALSE when: "Group permission updates" group.addPermission(new DummyPermission("p2")) then: "Negative permission also updates" - perm.getPermissionResolver().check("p1") == FALSE - perm.getPermissionResolver().check("p2") == FALSE + perm.check("p1") == FALSE + perm.check("p2") == FALSE } } diff --git a/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy index 2a112cd..5e1f01b 100644 --- a/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy +++ b/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy @@ -1,8 +1,13 @@ package org.ultramine.permission +import org.ultramine.permission.internal.MetaResolver +import org.ultramine.permission.internal.PermissionHolder +import org.ultramine.permission.internal.PermissionResolver import spock.lang.Specification -import static CheckResult.UNRESOLVED +import static org.ultramine.permission.internal.CheckResult.FALSE +import static org.ultramine.permission.internal.CheckResult.TRUE +import static org.ultramine.permission.internal.CheckResult.UNRESOLVED class PermissionHolderTest extends Specification { @@ -15,22 +20,28 @@ def "Test calculation"() { setup: - def resolver = Mock(PermissionResolver) - def perm1 = Mock(IPermission) { + def spy = Spy(PermissionResolver) + def perm1 = Stub(IPermission) { getKey() >> "p.1" - getPermissionResolver() >> resolver - getMeta() >> createMetaResolver([test1: "1", test2: "1", test3: "1"]) - getPriority() >> 1 + mergeMetaTo(_) >> { MetaResolver resolver -> + resolver.merge([test1: "1", test2: "1", test3: "1"], 1) + } + mergePermissionsTo(_) >> { PermissionResolver resolver -> + resolver.merge([test1: true, test2: true], 1) + } } - def perm2 = Mock(IPermission) { + def perm2 = Stub(IPermission) { getKey() >> "p.2" - getPermissionResolver() >> resolver - getMeta() >> createMetaResolver([test2: "2"]) - getPriority() >> 2 + mergeMetaTo(_) >> { MetaResolver resolver -> + resolver.merge([test2: "2"], 2) + } + mergePermissionsTo(_) >> { PermissionResolver resolver -> + resolver.merge([test2: false], 2) + } } def holder = new PermissionHolder([test1: "0"]) - holder.permissionResolver = resolver + holder.permissionResolver = spy holder.addPermission(perm1) holder.addPermission(perm2) @@ -39,46 +50,50 @@ then: "Permissions are calculated" !holder.isDirty() - 1 * resolver.clear() - 1 * resolver.merge(resolver, 1) - 1 * resolver.merge(resolver, 2) - 0 * resolver._ + holder.check("test1") == TRUE + holder.check("test2") == FALSE + holder.check("test3") == UNRESOLVED and: "Meta is correct" - holder.getMetaResolver().getString("test1") == "0" - holder.getMetaResolver().getString("test2") == "2" - holder.getMetaResolver().getString("test3") == "1" + holder.getMeta("test1") == "0" + holder.getMeta("test2") == "2" + holder.getMeta("test3") == "1" when: "Calculate one more time" holder.calculate() then: "Nothing happens" !holder.isDirty() - 0 * resolver._ + 0 * spy._ } def "Test clearPermissions"() { setup: def perm = Mock(IPermission) { getKey() >> "p1" - getPermissionResolver() >> PermissionResolver.createForKey("p1", 0) - getMeta() >> createMetaResolver([p1: 1]) + mergeMetaTo(_) >> { MetaResolver resolver -> + resolver.merge([test2: "1"], 0) + } + mergePermissionsTo(_) >> { PermissionResolver resolver -> + resolver.merge([test2: true], 0) + } } - def holder = new PermissionHolder([a: 1, b: 2]) + def holder = new PermissionHolder([a: "1", b: "2"]) holder.addPermission(new DummyPermission("p2")) holder.addPermission(perm) + holder.calculate() when: "Clear holder's permissions" holder.clearPermissions() then: "It contains only inner meta" - !holder.getMetaResolver().getInt("p1") - holder.getMetaResolver().getInt("a") == 1 - holder.getMetaResolver().getInt("b") == 2 + !holder.getMeta("test2") + holder.getMeta("a") == "1" + holder.getMeta("b") == "2" and: "It contains no permissions" - holder.getPermissionResolver().check("p1") == UNRESOLVED - holder.getPermissionResolver().check("p2") == UNRESOLVED + holder.check("test2") == UNRESOLVED + holder.check("p2") == UNRESOLVED and: "It unsubscribed from all permissions" 1 * perm.unsubscribe(holder) @@ -88,10 +103,14 @@ setup: def perm = Mock(IPermission) { getKey() >> "p1" - getPermissionResolver() >> PermissionResolver.createForKey("p1", 0) - getMeta() >> createMetaResolver([p1: 1]) + mergeMetaTo(_) >> { MetaResolver resolver -> + resolver.merge([test2: "1"], 0) + } + mergePermissionsTo(_) >> { PermissionResolver resolver -> + resolver.merge([test2: true], 0) + } } - def holder = new PermissionHolder([a: 1, b: 2]) + def holder = new PermissionHolder([a: "1", b: "2"]) holder.addPermission(new DummyPermission("p2")) holder.addPermission(perm) @@ -99,13 +118,13 @@ holder.clearMeta() then: "It contains only permission's meta" - holder.getMetaResolver().getInt("p1") == 1 - !holder.getMetaResolver().getInt("a") - !holder.getMetaResolver().getInt("b") + holder.getMeta("test2") == "1" + !holder.getMeta("a") + !holder.getMeta("b") and: "It contains all permissions" - holder.getPermissionResolver().check("p1") != UNRESOLVED - holder.getPermissionResolver().check("p2") != UNRESOLVED + holder.check("test2") != UNRESOLVED + holder.check("p2") != UNRESOLVED and: "It did not unsubscribe from all permissions" 0 * perm.unsubscribe(holder) @@ -129,7 +148,7 @@ when: "Call setMeta method" holder.calculate() - holder.setMeta("test", 21) + holder.setMeta("test", "21") then: "Group becomes dirty" 1 * holder.makeDirty() diff --git a/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy index 66a498f..674c8f3 100644 --- a/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy +++ b/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy @@ -3,85 +3,56 @@ import org.spockframework.mock.MockDetector import spock.lang.Specification -import static org.ultramine.permission.PermissionRepository.ProxyPermission.ProxyType.* -import static CheckResult.FALSE -import static CheckResult.TRUE -import static CheckResult.UNRESOLVED +import static org.ultramine.permission.internal.CheckResult.FALSE +import static org.ultramine.permission.internal.CheckResult.TRUE +import static org.ultramine.permission.internal.CheckResult.UNRESOLVED class PermissionRepositoryTest extends Specification { + def repository = new PermissionRepository() + def "Test get proxy permission"() { setup: def detector = new MockDetector() def perm = Mock(IPermission) { getKey() >> "key" - getName() >> "test" + getMeta(_) >> "test" } - def repository = new PermissionRepository() when: "Try to get not registered permission" def proxy = repository.getPermission("key") then: "Returned proxy of dummy permission" proxy.getWrappedPermission().class == DummyPermission - proxy.getType() == DUMMY - proxy.getName() == "key" + proxy.isDummy(); + proxy.getMeta("") == "" when: "Register this permission" repository.registerPermission(perm) then: "Proxy linked to added permission" detector.isMock(proxy.getWrappedPermission()) - proxy.getType() != DUMMY - proxy.getName() == "test" + !proxy.isDummy() + proxy.getMeta("") == "test" } def "Test registration of existed permission"() { - setup: - def repository = new PermissionRepository() when: "Register permission same key twice" - repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getName() >> "1" }) - repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getName() >> "2" }) + repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getMeta(_) >> "1" }) + repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getMeta(_) >> "2" }) then: "Exception is thrown" thrown(IllegalArgumentException) and: "First permission is not overwritten" - repository.getPermission("key").getName() == "1" + repository.getPermission("key").getMeta("") == "1" } def "Test proxy of IPermission"() { setup: def listener = Mock(IDirtyListener) def perm = Mock(IPermission) { getKey() >> "key" } - def repository = new PermissionRepository() - - when: "Listener is subscribed to proxy permission" - def proxy = repository.getPermission("key") - proxy.subscribe(listener) - - and: "And IPermission is registered" - repository.registerPermission(perm) - - then: "Listener is notified" - 1 * listener.makeDirty() - - and: "Proxy type is SIMPLE" - proxy.getType() == SIMPLE - - when: "Add another lister" - proxy.subscribe(Mock(IDirtyListener)) - - then: "noting is happened" - 0 * perm._ - } - - def "Test proxy of IChangeablePermission"() { - setup: - def listener = Mock(IDirtyListener) - def perm = Mock(IPermission) { getKey() >> "key" } - def repository = new PermissionRepository() when: "Listener is subscribed to proxy permission" def proxy = repository.getPermission("key") @@ -93,8 +64,8 @@ then: "Listener is notified" 1 * listener.makeDirty() - and: "Proxy type is CHANGEABLE" - proxy.getType() == CHANGEABLE + and: "Proxy is not Dummy" + !proxy.isDummy() and: "Listener is passed to permission" 1 * perm.subscribe(listener) @@ -116,14 +87,13 @@ setup: def listener = Mock(IDirtyListener) def perm = Mock(IPermission) { getKey() >> "key" } - def repository = new PermissionRepository() when: "Listener is subscribed and unsubscribe to proxy permission" def proxy = repository.getPermission("key") proxy.subscribe(listener) proxy.unsubscribe(listener) - and: "And IChangeablePermission is registered" + and: "And permission is registered" repository.registerPermission(perm) then: "0 listener passed to proxy" @@ -131,23 +101,19 @@ } def "Test negative key"() { - setup: - def repository = new PermissionRepository() when: "Try to get permission with negative key" def perm = repository.getPermission("^group.admin") then: "Proxy of negative permission is return" - perm.class == PermissionRepository.NegativePermission + perm.class == NegativePermission and: "Negative permission linked to proxy" - perm.getWrappedPermission().getName() == "group.admin" - perm.getWrappedPermission().getType() == DUMMY + perm.getWrappedPermission().getKey() == "group.admin" + perm.getWrappedPermission().class == PermissionRepository.ProxyPermission } def "Test registre ^* permission"() { - setup: - def repository = new PermissionRepository() when: "Try to register ^* permission" repository.registerPermission(Mock(IPermission) { getKey() >> "^test" }) @@ -158,7 +124,6 @@ def "Test integration"() { setup: - def repository = new PermissionRepository(); def group1 = new GroupPermission("group1") group1.addPermission(repository.getPermission("p1")) group1.addPermission(repository.getPermission("group2")) @@ -168,19 +133,19 @@ def perm = repository.getPermission("^group1") then: "Negative permission contains group1 permissions" - perm.getPermissionResolver().check("p1") == FALSE - perm.getPermissionResolver().check("p2") == UNRESOLVED - perm.getPermissionResolver().check("group2") == FALSE - perm.getPermissionResolver().check("p3") == UNRESOLVED + perm.check("p1") == FALSE + perm.check("p2") == UNRESOLVED + perm.check("group2") == FALSE + perm.check("p3") == UNRESOLVED when: "Group permission updates" group1.addPermission(repository.getPermission("p2")) then: "Negative permission also updates" - perm.getPermissionResolver().check("p1") == FALSE - perm.getPermissionResolver().check("p2") == FALSE - perm.getPermissionResolver().check("group2") == FALSE - perm.getPermissionResolver().check("p3") == UNRESOLVED + perm.check("p1") == FALSE + perm.check("p2") == FALSE + perm.check("group2") == FALSE + perm.check("p3") == UNRESOLVED when: "Register group2" def group2 = new GroupPermission("group2") @@ -188,15 +153,15 @@ repository.registerPermission(group2) then: "Negative permission also updates" - perm.getPermissionResolver().check("p1") == FALSE - perm.getPermissionResolver().check("p2") == FALSE - perm.getPermissionResolver().check("group2") == UNRESOLVED - perm.getPermissionResolver().check("p3") == TRUE + perm.check("p1") == FALSE + perm.check("p2") == FALSE + perm.check("group2") == UNRESOLVED + perm.check("p3") == TRUE and: "Group1 updates too" - group1.getPermissionResolver().check("p1") == TRUE - group1.getPermissionResolver().check("p2") == TRUE - group1.getPermissionResolver().check("group2") == UNRESOLVED - group1.getPermissionResolver().check("p3") == FALSE + group1.check("p1") == TRUE + group1.check("p2") == TRUE + group1.check("group2") == UNRESOLVED + group1.check("p3") == FALSE } } diff --git a/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy index 23811df..eae64a1 100644 --- a/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy +++ b/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy @@ -1,8 +1,9 @@ package org.ultramine.permission +import org.ultramine.permission.internal.PermissionResolver import spock.lang.Specification import spock.lang.Unroll -import static CheckResult.* +import static org.ultramine.permission.internal.CheckResult.* /** * Created by Евгений on 08.05.2014. diff --git a/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy b/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy index 3ad47e4..10f913f 100644 --- a/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy +++ b/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy @@ -1,16 +1,14 @@ package org.ultramine.permission +import org.ultramine.permission.internal.UserContainer import spock.lang.Specification class UserContainerTest extends Specification { def stubUser(String name, Map permissions) { - def resolver = new PermissionResolver(); - resolver.merge(permissions, 0) - Mock(User) { - getName() >> name - getPermissionResolver() >> resolver - } + def user = new User(name) + user.permissionResolver.merge(permissions, 0) + return user } def "Test permissions"() { diff --git a/src/test/groovy/org/ultramine/permission/WorldTest.groovy b/src/test/groovy/org/ultramine/permission/WorldTest.groovy index a0db744..22f802b 100644 --- a/src/test/groovy/org/ultramine/permission/WorldTest.groovy +++ b/src/test/groovy/org/ultramine/permission/WorldTest.groovy @@ -23,11 +23,11 @@ !container.checkUserPermission("user2", "group.admin") and: "Meta is loaded correctly" - container.get("user1").getMetaResolver().getString("a") == "a" - container.get("user1").getMetaResolver().getInt("b") == 1 + container.get("user1").getMeta("a") == "a" + container.get("user1").getMeta("b") == "1" - !container.get("user2").getMetaResolver().getString("a") - !container.get("user2").getMetaResolver().getInt("b") + !container.get("user2").getMeta("a") + !container.get("user2").getMeta("b") } def "Test config reloading"() { @@ -42,14 +42,14 @@ then: "User have this permission and meta" container.checkUserPermission("user1", "test") - container.get("user2").getMetaResolver().getString("test") == "data" + container.get("user2").getMeta("test") == "data" when: "Reloading container" container.load(testWorldData) then: "User have not this permission and meta" !container.checkUserPermission("user1", "test") - !container.get("user2").getMetaResolver().getString("test") + !container.get("user2").getMeta("test") and: "Container is reloaded correctly" container.checkUserPermission("user1", "d") @@ -64,10 +64,10 @@ container.checkUserPermission("user2", "p.3") !container.checkUserPermission("user2", "group.admin") - container.get("user1").getMetaResolver().getString("a") == "a" - container.get("user1").getMetaResolver().getInt("b") == 1 - !container.get("user2").getMetaResolver().getString("a") - !container.get("user2").getMetaResolver().getInt("b") + container.get("user1").getMeta("a") == "a" + container.get("user1").getMeta("b") == "1" + !container.get("user2").getMeta("a") + !container.get("user2").getMeta("b") } def "Test config saving"() { @@ -113,7 +113,7 @@ users: [ user1: new World.HolderData( permissions: ['p.1', '^p.2'], - meta: [a: 'a', b: 1] + meta: [a: 'a', b: "1"] ), user2: new World.HolderData( permissions: ['^d', 'p.3'],