Allow set flags to be manipulate via keywords

This adds support for updating an existing region, so that
if you have a long list of items in a set flag, such as
`deny-spawn` you can add or remove items, rather than overwrite.

Example:
```
/rg flag test deny-spawn add creeper
/rg flag test deny-spawn remove zombie
```

CHANGELOG.md

@@ -1,11 +1,5 @@
 # Changelog
 
-## 7.0.2
-* Update to MC 1.15. Still compatible with 1.14, and incompatible with 1.13, as before.
-* Add an informational message when defining a region that overlaps vanilla spawn protection.
-* Protect against pushing a piston with another piston on a region border.
-* Protect against buckets in dispensers on region borders.
-
 ## 7.0.1
 * Add `/rg toggle-bypass` command which temporarily turns off region bypassing until used again.
 * More improvements to `/rg flag` and `/rg flags` commands.

gradle.properties

@@ -1,2 +1,2 @@
 group=com.sk89q.worldguard
-version=7.0.2
+version=7.0.2-SNAPSHOT

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/SetFlag.java

@@ -20,18 +20,25 @@
 package com.sk89q.worldguard.protection.flags;
 
 import com.google.common.collect.Sets;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Stores a set of types.
  */
 public class SetFlag<T> extends Flag<Set<T>> {
 
+    private static final Pattern ANY_MODIFIER = Pattern.compile("^(add|sub|subtract|rem|remove) (.*)$");
+    private static final Pattern REMOVE_MODIFIERS = Pattern.compile("^(sub|subtract|rem|remove) (.*)$");
+
     private Flag<T> subFlag;
 
     public SetFlag(String name, RegionGroup defaultGroup, Flag<T> subFlag) {
@@ -60,10 +67,32 @@ public class SetFlag<T> extends Flag<Set<T>> {
             return Sets.newHashSet();
         } else {
             Set<T> items = Sets.newHashSet();
+            boolean subtractive = false;
+
+            // If the input starts with particular keywords, attempt to load the existing values,
+            // and make this a modification, instead of an overwrite.
+            Matcher keywordMatcher = ANY_MODIFIER.matcher(input);
+            if (keywordMatcher.matches()) {
+                ProtectedRegion region = Objects.requireNonNull((ProtectedRegion) context.get("region"));
+
+                Set<T> existingValue = region.getFlag(this);
+                if (existingValue != null) {
+                    items.addAll(existingValue);
+                }
+
+                subtractive = REMOVE_MODIFIERS.matcher(input).matches();
+                input = keywordMatcher.group(2);
+            }
 
             for (String str : input.split(",")) {
                 FlagContext copy = context.copyWith(null, str, null);
-                items.add(subFlag.parseInput(copy));
+
+                T subFlagValue = subFlag.parseInput(copy);
+                if (subtractive) {
+                    items.remove(subFlagValue);
+                } else {
+                    items.add(subFlagValue);
+                }
             }
 
             return items;