More work

api/src/main/java/net/luckperms/api/context/ContextManager.java

@@ -75,7 +75,7 @@ public interface ContextManager {
      * @param user the user
      * @return the applicable context for the subject
      */
-    @NonNull Optional<ImmutableContextSet> lookupContext(@NonNull User user);
+    @NonNull Optional<ImmutableContextSet> getContext(@NonNull User user);
 
     /**
      * Gets the contexts from the static calculators in this manager.
@@ -115,7 +115,7 @@ public interface ContextManager {
      * @param user the user
      * @return the query options for the subject
      */
-    @NonNull Optional<QueryOptions> lookupQueryOptions(@NonNull User user);
+    @NonNull Optional<QueryOptions> getQueryOptions(@NonNull User user);
 
     /**
      * Gets the static query options, using the registered static context calculators.
@@ -124,29 +124,6 @@ public interface ContextManager {
      */
     @NonNull QueryOptions getStaticQueryOptions();
 
-    /**
-     * Forms a {@link QueryOptions} instance from an {@link ImmutableContextSet}.
-     *
-     * <p>This method relies on the plugins configuration to form the
-     * {@link QueryOptions} instance.</p>
-     *
-     * @param subject    the reference subject
-     * @param contextSet the context set
-     * @return a options instance
-     */
-    @NonNull QueryOptions formQueryOptions(@NonNull Object subject, @NonNull ImmutableContextSet contextSet);
-
-    /**
-     * Forms a {@link QueryOptions} instance from an {@link ImmutableContextSet}.
-     *
-     * <p>This method relies on the plugins configuration to form the
-     * {@link QueryOptions} instance.</p>
-     *
-     * @param contextSet the context set
-     * @return a options instance
-     */
-    @NonNull QueryOptions formQueryOptions(@NonNull ImmutableContextSet contextSet);
-
     /**
      * Registers a context calculator with the manager.
      *

api/src/main/java/net/luckperms/api/event/track/mutate/TrackMutateEvent.java

@@ -52,7 +52,7 @@ public interface TrackMutateEvent extends LuckPermsEvent {
      * @return the data before the change
      */
     @Param(1)
-    @NonNull List<String> getDataBefore();
+    @NonNull List<String> getStateBefore();
 
     /**
      * Gets an immutable copy of the tracks data after the change
@@ -60,6 +60,6 @@ public interface TrackMutateEvent extends LuckPermsEvent {
      * @return the data after the change
      */
     @Param(2)
-    @NonNull List<String> getDataAfter();
+    @NonNull List<String> getStateAfter();
 
 }

api/src/main/java/net/luckperms/api/metastacking/MetaStackFactory.java

@@ -53,19 +53,6 @@ public interface MetaStackFactory {
      */
     @NonNull List<MetaStackElement> fromStrings(@NonNull List<String> definitions);
 
-    /**
-     * Creates a new {@link MetaStackDefinition} with the given properties.
-     *
-     * @param elements     the elements to be included in the stack.
-     * @param startSpacer  the spacer to be included at the start of the stacks output
-     * @param middleSpacer the spacer to be included between stack elements
-     * @param endSpacer    the spacer to be included at the end of the stacks output
-     * @return the new stack definition instance
-     */
-    default @NonNull MetaStackDefinition createDefinition(@NonNull List<MetaStackElement> elements, @NonNull String startSpacer, @NonNull String middleSpacer, @NonNull String endSpacer) {
-        return createDefinition(elements, DuplicateRemovalFunction.RETAIN_ALL, startSpacer, middleSpacer, endSpacer);
-    }
-
     /**
      * Creates a new {@link MetaStackDefinition} with the given properties.
      *

api/src/main/java/net/luckperms/api/model/PermissionHolder.java

@@ -48,7 +48,6 @@ import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
 import java.util.function.Predicate;
 
 /**
@@ -127,16 +126,6 @@ public interface PermissionHolder {
      */
     @NonNull CachedDataManager getCachedData();
 
-    /**
-     * Refreshes and applies any changes to the cached holder data.
-     *
-     * <p>Calling this method is unnecessary in most cases. Cache updates are handled
-     * behind the scenes by the implementation.</p>
-     *
-     * @return the task future
-     */
-    @NonNull CompletableFuture<Void> refreshCachedData();
-
     /**
      * Gets the {@link Data} of a particular type.
      *

api/src/main/java/net/luckperms/api/model/user/UserManager.java

@@ -152,11 +152,11 @@ public interface UserManager {
     /**
      * Gets a loaded user.
      *
-     * @param name the username of the user to get
+     * @param username the username of the user to get
      * @return a {@link User} object, if one matching the uuid is loaded, or null if not
      * @throws NullPointerException if the name is null
      */
-    @Nullable User getUser(@NonNull String name);
+    @Nullable User getUser(@NonNull String username);
 
     /**
      * Gets a set of all loaded users.

common/src/main/java/me/lucko/luckperms/common/api/MinimalApiProvider.java

@@ -138,13 +138,11 @@ public class MinimalApiProvider implements LuckPerms {
         }
 
         @Override public @NonNull ImmutableContextSet getContext(@NonNull Object subject) { throw exception(); }
-        @Override public @NonNull Optional<ImmutableContextSet> lookupContext(@NonNull User user) { throw exception(); }
+        @Override public @NonNull Optional<ImmutableContextSet> getContext(@NonNull User user) { throw exception(); }
         @Override public @NonNull ImmutableContextSet getStaticContext() { throw exception(); }
         @Override public @NonNull QueryOptions getQueryOptions(@NonNull Object subject) { throw exception(); }
-        @Override public @NonNull Optional<QueryOptions> lookupQueryOptions(@NonNull User user) { throw exception(); }
+        @Override public @NonNull Optional<QueryOptions> getQueryOptions(@NonNull User user) { throw exception(); }
         @Override public @NonNull QueryOptions getStaticQueryOptions() { throw exception(); }
-        @Override public @NonNull QueryOptions formQueryOptions(@NonNull Object subject, @NonNull ImmutableContextSet contextSet) { throw exception(); }
-        @Override public @NonNull QueryOptions formQueryOptions(@NonNull ImmutableContextSet contextSet) { throw exception(); }
         @Override public void registerCalculator(@NonNull ContextCalculator<?> calculator) { throw exception(); }
         @Override public void unregisterCalculator(@NonNull ContextCalculator<?> calculator) { throw exception(); }
         @Override public void invalidateCache(@NonNull Object subject) { throw exception(); }

common/src/main/java/me/lucko/luckperms/common/api/implementation/ApiContextManager.java

@@ -65,7 +65,7 @@ public class ApiContextManager implements net.luckperms.api.context.ContextManag
     }
 
     @Override
-    public @NonNull Optional<ImmutableContextSet> lookupContext(@NonNull User user) {
+    public @NonNull Optional<ImmutableContextSet> getContext(@NonNull User user) {
         Objects.requireNonNull(user, "user");
         return this.plugin.getQueryOptionsForUser(ApiUser.cast(user)).map(QueryOptions::context);
     }
@@ -88,7 +88,7 @@ public class ApiContextManager implements net.luckperms.api.context.ContextManag
     }
 
     @Override
-    public @NonNull Optional<QueryOptions> lookupQueryOptions(@NonNull User user) {
+    public @NonNull Optional<QueryOptions> getQueryOptions(@NonNull User user) {
         Objects.requireNonNull(user, "user");
         return this.plugin.getQueryOptionsForUser(ApiUser.cast(user));
     }
@@ -98,19 +98,6 @@ public class ApiContextManager implements net.luckperms.api.context.ContextManag
         return this.handle.getStaticQueryOptions();
     }
 
-    @Override
-    public @NonNull QueryOptions formQueryOptions(@NonNull Object subject, @NonNull ImmutableContextSet contextSet) {
-        Objects.requireNonNull(subject, "subject");
-        Objects.requireNonNull(contextSet, "contextSet");
-        return this.handle.formQueryOptions(subject, contextSet);
-    }
-
-    @Override
-    public @NonNull QueryOptions formQueryOptions(@NonNull ImmutableContextSet contextSet) {
-        Objects.requireNonNull(contextSet, "contextSet");
-        return this.handle.formQueryOptions(contextSet);
-    }
-
     @Override
     public void registerCalculator(@NonNull ContextCalculator<?> calculator) {
         Objects.requireNonNull(calculator, "calculator");

common/src/main/java/me/lucko/luckperms/common/api/implementation/ApiPermissionHolder.java

@@ -25,10 +25,7 @@
 
 package me.lucko.luckperms.common.api.implementation;
 
-import com.google.common.collect.ImmutableSortedSet;
-
 import me.lucko.luckperms.common.model.PermissionHolder;
-import me.lucko.luckperms.common.node.comparator.NodeWithContextComparator;
 
 import net.luckperms.api.cacheddata.CachedDataManager;
 import net.luckperms.api.context.ContextSet;
@@ -46,15 +43,11 @@ import net.luckperms.api.query.QueryOptions;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
-import java.util.TreeSet;
-import java.util.concurrent.CompletableFuture;
 import java.util.function.Predicate;
 
 public class ApiPermissionHolder implements net.luckperms.api.model.PermissionHolder {
@@ -88,11 +81,6 @@ public class ApiPermissionHolder implements net.luckperms.api.model.PermissionHo
         return this.handle.getCachedData();
     }
 
-    @Override
-    public @NonNull CompletableFuture<Void> refreshCachedData() {
-        return CompletableFuture.runAsync(() -> this.handle.getCachedData().invalidate());
-    }
-
     @Override
     public Data getData(@NonNull DataType dataType) {
         switch (dataType) {
@@ -127,28 +115,12 @@ public class ApiPermissionHolder implements net.luckperms.api.model.PermissionHo
 
     @Override
     public @NonNull List<Node> resolveInheritedNodes(@NonNull QueryOptions queryOptions) {
-        return this.handle.resolveInheritances(queryOptions);
+        return this.handle.resolveInheritedNodes(queryOptions);
     }
 
     @Override
     public @NonNull SortedSet<Node> resolveDistinctInheritedNodes(@NonNull QueryOptions queryOptions) {
-        List<Node> entries = this.handle.getAllEntries(queryOptions);
+        return this.handle.resolveInheritedNodesSorted(queryOptions);
-
-        removeSamePermission(entries.iterator());
-        SortedSet<Node> ret = new TreeSet<>(NodeWithContextComparator.reverse());
-        ret.addAll(entries);
-
-        return ImmutableSortedSet.copyOfSorted(ret);
-    }
-
-    private static <T extends Node> void removeSamePermission(Iterator<T> it) {
-        Set<String> alreadyIn = new HashSet<>();
-        while (it.hasNext()) {
-            T next = it.next();
-            if (!alreadyIn.add(next.getKey())) {
-                it.remove();
-            }
-        }
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/api/implementation/ApiUserManager.java

@@ -114,9 +114,9 @@ public class ApiUserManager extends ApiAbstractManager<User, net.luckperms.api.m
     }
 
     @Override
-    public net.luckperms.api.model.user.User getUser(@NonNull String name) {
+    public net.luckperms.api.model.user.User getUser(@NonNull String username) {
-        Objects.requireNonNull(name, "name");
+        Objects.requireNonNull(username, "name");
-        return getDelegateFor(this.handle.getByUsername(name));
+        return getDelegateFor(this.handle.getByUsername(username));
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/commands/generic/meta/MetaInfo.java

@@ -89,7 +89,7 @@ public class MetaInfo extends SharedSubCommand {
         Set<MetaNode> meta = new LinkedHashSet<>();
 
         // Collect data
-        for (Node node : holder.resolveInheritances(QueryOptions.nonContextual())) {
+        for (Node node : holder.resolveInheritedNodes(QueryOptions.nonContextual())) {
             if (!NodeType.META_OR_CHAT_META.matches(node)) {
                 continue;
             }

common/src/main/java/me/lucko/luckperms/common/commands/generic/permission/PermissionCheckInherits.java

@@ -66,7 +66,7 @@ public class PermissionCheckInherits extends SharedSubCommand {
         String node = ArgumentParser.parseString(0, args);
         MutableContextSet context = ArgumentParser.parseContext(1, args, plugin);
 
-        Optional<Node> match = holder.resolveInheritances(QueryOptions.nonContextual()).stream()
+        Optional<Node> match = holder.resolveInheritedNodes(QueryOptions.nonContextual()).stream()
                 .filter(n -> n.getKey().equalsIgnoreCase(node) && n.getContexts().equals(context))
                 .findFirst();
 

common/src/main/java/me/lucko/luckperms/common/extension/SimpleExtensionManager.java

@@ -81,6 +81,7 @@ public class SimpleExtensionManager implements ExtensionManager, AutoCloseable {
         if (this.extensions.stream().anyMatch(e -> e.instance.equals(extension))) {
             return;
         }
+        this.plugin.getLogger().info("Loading extension: " + extension.getClass().getName());
         this.extensions.add(new LoadedExtension(extension, null, null));
         extension.load();
         this.plugin.getEventFactory().handleExtensionLoad(extension);
@@ -93,10 +94,12 @@ public class SimpleExtensionManager implements ExtensionManager, AutoCloseable {
 
         try (Stream<Path> stream = Files.list(directory)) {
             stream.forEach(path -> {
+                if (path.getFileName().toString().endsWith(".jar")) {
                     try {
                         loadExtension(path);
                     } catch (IOException e) {
-                    e.printStackTrace();
+                        new RuntimeException("Exception loading extension from " + path, e).printStackTrace();
+                    }
                 }
             });
         } catch (IOException e) {
@@ -119,7 +122,7 @@ public class SimpleExtensionManager implements ExtensionManager, AutoCloseable {
 
         try (InputStream in = classLoader.getResourceAsStream("extension.json")) {
             if (in == null) {
-                throw new RuntimeException("extension.json not present in " + path.toString());
+                throw new IllegalStateException("extension.json not present");
             }
             try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
                 JsonElement parsed = GsonProvider.parser().parse(reader);
@@ -138,6 +141,8 @@ public class SimpleExtensionManager implements ExtensionManager, AutoCloseable {
             throw new RuntimeException(e);
         }
 
+        this.plugin.getLogger().info("Loading extension: " + extensionClass.getName() + " (" + path.getFileName().toString() + ")");
+
         Extension extension = null;
 
         try {
@@ -153,7 +158,9 @@ public class SimpleExtensionManager implements ExtensionManager, AutoCloseable {
             try {
                 Constructor<? extends Extension> constructor = extensionClass.getConstructor();
                 extension = constructor.newInstance();
-            } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException("Unable to find valid constructor in " + extensionClass.getName());
+            } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
                 throw new RuntimeException(e);
             }
         }

common/src/main/java/me/lucko/luckperms/common/inheritance/InheritanceGraph.java

@@ -32,9 +32,7 @@ import me.lucko.luckperms.common.model.Group;
 import me.lucko.luckperms.common.model.PermissionHolder;
 import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
 
-import net.luckperms.api.context.DefaultContextKeys;
 import net.luckperms.api.node.types.InheritanceNode;
-import net.luckperms.api.query.Flag;
 import net.luckperms.api.query.QueryOptions;
 
 import java.util.ArrayList;
@@ -62,12 +60,6 @@ public class InheritanceGraph implements Graph<PermissionHolder> {
     public Iterable<? extends PermissionHolder> successors(PermissionHolder holder) {
         Set<Group> successors = new LinkedHashSet<>();
         for (InheritanceNode n : holder.getOwnInheritanceNodes(this.queryOptions)) {
-            // effectively: if not (we're applying global groups or it's specific anyways)
-            if (!((this.queryOptions.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_SERVER_CONTEXT) || n.getContexts().containsKey(DefaultContextKeys.SERVER_KEY)) &&
-                    (this.queryOptions.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_WORLD_CONTEXT) || n.getContexts().containsKey(DefaultContextKeys.WORLD_KEY)))) {
-                continue;
-            }
-
             Group g = this.plugin.getGroupManager().getIfLoaded(n.getGroupName());
             if (g != null) {
                 successors.add(g);

common/src/main/java/me/lucko/luckperms/common/model/NodeMap.java

@@ -37,11 +37,13 @@ import me.lucko.luckperms.common.node.comparator.NodeWithContextComparator;
 import me.lucko.luckperms.common.node.model.InheritanceOrigin;
 
 import net.luckperms.api.context.ContextSet;
+import net.luckperms.api.context.DefaultContextKeys;
 import net.luckperms.api.context.ImmutableContextSet;
 import net.luckperms.api.node.Node;
 import net.luckperms.api.node.NodeEqualityPredicate;
 import net.luckperms.api.node.metadata.types.InheritanceOriginMetadata;
 import net.luckperms.api.node.types.InheritanceNode;
+import net.luckperms.api.query.Flag;
 import net.luckperms.api.query.QueryOptions;
 
 import org.checkerframework.checker.nullness.qual.NonNull;
@@ -135,18 +137,43 @@ public final class NodeMap {
     public void copyTo(Collection<? super Node> collection, QueryOptions filter) {
         for (Map.Entry<ImmutableContextSet, SortedSet<Node>> e : this.map.entrySet()) {
             if (filter.satisfies(e.getKey())) {
+                boolean serverMissing = !e.getKey().containsKey(DefaultContextKeys.SERVER_KEY);
+                boolean worldMissing = !e.getKey().containsKey(DefaultContextKeys.WORLD_KEY);
+                boolean excludeAsServerMissing = !filter.flag(Flag.INCLUDE_NODES_WITHOUT_SERVER_CONTEXT) && serverMissing;
+                boolean excludeAsWorldMissing = !filter.flag(Flag.INCLUDE_NODES_WITHOUT_WORLD_CONTEXT) && worldMissing;
+
+                if (excludeAsServerMissing || excludeAsWorldMissing) {
+                    boolean excludeInheritanceAsServerMissing = !filter.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_SERVER_CONTEXT) && serverMissing;
+                    boolean excludeInheritanceAsWorldMissing = !filter.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_WORLD_CONTEXT) && worldMissing;
+
+                    if (!excludeInheritanceAsServerMissing && !excludeInheritanceAsWorldMissing) {
+                        // only copy inheritance nodes.
+                        SortedSet<InheritanceNode> inheritanceNodes = this.inheritanceMap.get(e.getKey());
+                        if (inheritanceNodes != null) {
+                            collection.addAll(inheritanceNodes);
+                        }
+                    }
+                } else {
                     collection.addAll(e.getValue());
                 }
             }
         }
+    }
 
     public void copyInheritanceNodesTo(Collection<? super InheritanceNode> collection, QueryOptions filter) {
         for (Map.Entry<ImmutableContextSet, SortedSet<InheritanceNode>> e : this.inheritanceMap.entrySet()) {
             if (filter.satisfies(e.getKey())) {
+                boolean serverMissing = !e.getKey().containsKey(DefaultContextKeys.SERVER_KEY);
+                boolean worldMissing = !e.getKey().containsKey(DefaultContextKeys.WORLD_KEY);
+                boolean excludeInheritanceAsServerMissing = !filter.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_SERVER_CONTEXT) && serverMissing;
+                boolean excludeInheritanceAsWorldMissing = !filter.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_WORLD_CONTEXT) && worldMissing;
+
+                if (!excludeInheritanceAsServerMissing && !excludeInheritanceAsWorldMissing) {
                     collection.addAll(e.getValue());
                 }
             }
         }
+    }
 
     /**
      * Returns an immutable representation of the maps current state.

common/src/main/java/me/lucko/luckperms/common/model/PermissionHolder.java

@@ -37,7 +37,6 @@ import me.lucko.luckperms.common.node.comparator.NodeWithContextComparator;
 import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
 
 import net.luckperms.api.context.ContextSet;
-import net.luckperms.api.context.DefaultContextKeys;
 import net.luckperms.api.context.ImmutableContextSet;
 import net.luckperms.api.model.DataMutateResult;
 import net.luckperms.api.model.DataType;
@@ -63,7 +62,6 @@ import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.OptionalInt;
@@ -279,41 +277,33 @@ public abstract class PermissionHolder {
         return ret;
     }
 
-    public void accumulateInheritancesTo(List<? super Node> accumulator, QueryOptions queryOptions) {
+    private void accumulateInheritedNodesTo(Collection<Node> accumulator, QueryOptions queryOptions) {
+        if (queryOptions.flag(Flag.RESOLVE_INHERITANCE)) {
             InheritanceGraph graph = this.plugin.getInheritanceHandler().getGraph(queryOptions);
             Iterable<PermissionHolder> traversal = graph.traverse(this);
             for (PermissionHolder holder : traversal) {
                 List<? extends Node> nodes = holder.getOwnNodes(queryOptions);
                 accumulator.addAll(nodes);
             }
-    }
-
-    public List<Node> resolveInheritances(QueryOptions queryOptions) {
-        List<Node> accumulator = new ArrayList<>();
-        accumulateInheritancesTo(accumulator, queryOptions);
-        return accumulator;
-    }
-
-    public List<Node> getAllEntries(QueryOptions queryOptions) {
-        List<Node> entries = new LinkedList<>();
-        if (queryOptions.flag(Flag.RESOLVE_INHERITANCE)) {
-            accumulateInheritancesTo(entries, queryOptions);
         } else {
-            entries.addAll(getOwnNodes(queryOptions));
+            accumulator.addAll(getOwnNodes(queryOptions));
+        }
     }
 
-        if (!queryOptions.flag(Flag.INCLUDE_NODES_WITHOUT_SERVER_CONTEXT)) {
+    public List<Node> resolveInheritedNodes(QueryOptions queryOptions) {
-            entries.removeIf(n -> !(n instanceof InheritanceNode) && !n.getContexts().containsKey(DefaultContextKeys.SERVER_KEY));
+        List<Node> ret = new ArrayList<>();
-        }
+        accumulateInheritedNodesTo(ret, queryOptions);
-        if (!queryOptions.flag(Flag.INCLUDE_NODES_WITHOUT_WORLD_CONTEXT)) {
+        return ret;
-            entries.removeIf(n -> !(n instanceof InheritanceNode) && !n.getContexts().containsKey(DefaultContextKeys.WORLD_KEY));
     }
 
-        return entries;
+    public SortedSet<Node> resolveInheritedNodesSorted(QueryOptions queryOptions) {
+        SortedSet<Node> ret = new TreeSet<>(NodeWithContextComparator.reverse());
+        accumulateInheritedNodesTo(ret, queryOptions);
+        return ret;
     }
 
     public Map<String, Boolean> exportPermissions(QueryOptions queryOptions, boolean convertToLowercase, boolean resolveShorthand) {
-        List<Node> entries = getAllEntries(queryOptions);
+        List<Node> entries = resolveInheritedNodes(queryOptions);
         return processExportedPermissions(entries, convertToLowercase, resolveShorthand);
     }
 
@@ -356,12 +346,6 @@ public abstract class PermissionHolder {
                 if (!node.getValue()) continue;
                 if (!NodeType.META_OR_CHAT_META.matches(node)) continue;
 
-                // effectively: if not (we're applying global groups or it's specific anyways)
-                if (!((queryOptions.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_SERVER_CONTEXT) || node.getContexts().containsKey(DefaultContextKeys.SERVER_KEY)) &&
-                        (queryOptions.flag(Flag.APPLY_INHERITANCE_NODES_WITHOUT_WORLD_CONTEXT) || node.getContexts().containsKey(DefaultContextKeys.WORLD_KEY)))) {
-                    continue;
-                }
-
                 accumulator.accumulateNode(node);
             }