Coercion of string "false" to boolean now provides a warning.

This is usually not what the user meant to do, as string "false"
evaluates to boolean true. Therefore, when we try to coerce a string
into a boolean, we first check to see if it is the string "false" and
if so, issue a warning. Eventually, I would like this to be configurable
per file, or at least at a more granular level, but anyways, for now 
this is a globally configurable warning in the logger-preferences.ini
settings.

This also required a change to the Static.getBoolean method, which has
been updated throughout the codebase to add a Target parameter. 
However, because extensions may
be using this method, it remains backwards compatible for now, but
the no Target method is deprecated and should be removed at next major
version change.

Author: LadyCailin

src/main/java/com/laytonsmith/core/ArgumentValidation.java

@@ -337,6 +337,11 @@ public static boolean getBoolean(Construct c, Target t) {
 		if(c instanceof CBoolean) {
 			b = ((CBoolean) c).getBoolean();
 		} else if(c instanceof CString) {
+			if(((CString)c).val().equals("false")) {
+				CHLog.GetLogger().e(CHLog.Tags.FALSESTRING, "String \"false\" evaluates as true (non-empty strings are"
+						+ " true). This is most likely not what you meant to do. This warning can globally be disabled"
+						+ " with the logger-preferences.ini file.", t);
+			}
 			b = (c.val().length() > 0);
 		} else if(c instanceof CInt || c instanceof CDouble) {
 			b = !(getNumber(c, t) == 0);

src/main/java/com/laytonsmith/core/CHLog.java

@@ -47,6 +47,8 @@ private CHLog() {
 	public enum Tags {
 		COMPILER("compiler", "Logs compiler errors (but not runtime errors)", LogLevel.WARNING),
 		RUNTIME("runtime", "Logs runtime errors, (exceptions that bubble all the way to the top)", LogLevel.ERROR),
+		FALSESTRING("falsestring", "Logs coersion of the string \"false\" to boolean, which is actually true", 
+			LogLevel.ERROR),
 		DEPRECATION("deprecation", "Shows deprecation warnings", LogLevel.WARNING),
 		PERSISTENCE("persistence", "Logs when any persistence actions occur.", LogLevel.ERROR),
 		//TODO Add the rest of these hooks into the code
@@ -115,7 +117,12 @@ private static LogLevel GetLevel(Tags tag) {
 		}
 		LogLevel level;
 		try {
-			level = LogLevel.valueOf((String) prefs.getPreference(tag.name));
+			String pref = (String) prefs.getPreference(tag.name);
+			if("ON".equals(pref)) {
+				level = LogLevel.ERROR;
+			} else {
+				level = LogLevel.valueOf(pref);
+			}
 		} catch(IllegalArgumentException e) {
 			level = LogLevel.ERROR;
 		}

src/main/java/com/laytonsmith/core/ObjectGenerator.java

@@ -576,7 +576,7 @@ public MCItemMeta itemMeta(Construct c, MCMaterial mat, Target t) throws ConfigR
 
 					if(Static.getServer().getMinecraftVersion().gte(MCVersion.MC1_11)) {
 						if(ma.containsKey("unbreakable")) {
-							meta.setUnbreakable(Static.getBoolean(ma.get("unbreakable", t)));
+							meta.setUnbreakable(Static.getBoolean(ma.get("unbreakable", t), t));
 						}
 					}
 				}
@@ -1040,10 +1040,10 @@ public List<MCLivingEntity.MCEffect> potions(CArray ea, Target t) {
 					}
 				}
 				if(effect.containsKey("ambient")) {
-					ambient = Static.getBoolean(effect.get("ambient", t));
+					ambient = Static.getBoolean(effect.get("ambient", t), t);
 				}
 				if(effect.containsKey("particles")) {
-					particles = Static.getBoolean(effect.get("particles", t));
+					particles = Static.getBoolean(effect.get("particles", t), t);
 				}
 				ret.add(new MCLivingEntity.MCEffect(potionID, strength, (int) (seconds * 20), ambient, particles));
 			} else {
@@ -1116,10 +1116,10 @@ public CArray fireworkEffect(MCFireworkEffect mcfe, Target t) {
 	public MCFireworkEffect fireworkEffect(CArray fe, Target t) {
 		MCFireworkBuilder builder = StaticLayer.GetConvertor().GetFireworkBuilder();
 		if(fe.containsKey("flicker")) {
-			builder.setFlicker(Static.getBoolean(fe.get("flicker", t)));
+			builder.setFlicker(Static.getBoolean(fe.get("flicker", t), t));
 		}
 		if(fe.containsKey("trail")) {
-			builder.setTrail(Static.getBoolean(fe.get("trail", t)));
+			builder.setTrail(Static.getBoolean(fe.get("trail", t), t));
 		}
 		if(fe.containsKey("colors")) {
 			Construct colors = fe.get("colors", t);

src/main/java/com/laytonsmith/core/Static.java

@@ -238,10 +238,28 @@ public static byte getInt8(Construct c, Target t) {
 	 * is empty, it is false, otherwise it is true.
 	 *
 	 * @param c
+	 * @param t
 	 * @return
 	 */
+	public static boolean getBoolean(Construct c, Target t) {
+		return ArgumentValidation.getBoolean(c, t);
+	}
+	
+	/**
+	 * Returns a boolean from any given construct. Depending on the type of the construct being converted, it follows
+	 * the following rules: If it is an integer or a double, it is false if 0, true otherwise. If it is a string, if it
+	 * is empty, it is false, otherwise it is true.
+	 *
+	 * @param c
+	 * @return
+	 * @deprecated Use 
+	 * {@link #getBoolean(com.laytonsmith.core.constructs.Construct, com.laytonsmith.core.constructs.Target)}
+	 * instead, as it provides better error messages for users that use the string "false" as a boolean. This method
+	 * should be removed in version 3.3.3 or above.
+	 */
+	@Deprecated
 	public static boolean getBoolean(Construct c) {
-		return ArgumentValidation.getBoolean(c, Target.UNKNOWN);
+		return getBoolean(c, Target.UNKNOWN);
 	}
 
 	/**

src/main/java/com/laytonsmith/core/compiler/FileOptions.java

@@ -1,9 +1,16 @@
 package com.laytonsmith.core.compiler;
 
+import com.laytonsmith.PureUtilities.ClassLoading.ClassDiscovery;
+import com.laytonsmith.PureUtilities.Version;
+import com.laytonsmith.core.CHVersion;
+import com.laytonsmith.core.Documentation;
 import com.laytonsmith.core.Prefs;
+import java.net.URL;
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  *
@@ -12,10 +19,10 @@
 public class FileOptions {
 
 	/*
-     These values are used in the syntax highlighter, and should remain the name they are in code.
+     These value names are used in the syntax highlighter, and should remain the name they are in code.
 	 */
 	private final Boolean strict;
-	private final List<String> suppressWarnings;
+	private final Set<SuppressWarnings> suppressWarnings;
 	private final String name;
 	private final String author;
 	private final String created;
@@ -24,7 +31,7 @@ public class FileOptions {
 
 	public FileOptions(Map<String, String> parsedOptions) {
 		strict = parseBoolean(getDefault(parsedOptions, "strict", null));
-		suppressWarnings = parseList(getDefault(parsedOptions, "suppresswarnings", ""));
+		suppressWarnings = parseEnumSet(getDefault(parsedOptions, "suppresswarnings", ""), SuppressWarnings.class);
 		name = getDefault(parsedOptions, "name", "");
 		author = getDefault(parsedOptions, "author", "");
 		created = getDefault(parsedOptions, "created", "");
@@ -55,6 +62,20 @@ private List<String> parseList(String list) {
 		}
 		return l;
 	}
+	
+	private <T extends Enum<T>> Set<T> parseEnumSet(String list, Class<T> type) {
+		EnumSet<T> set = EnumSet.noneOf(type);
+		List<String> sList = parseList(list);
+		for(String s : sList) {
+			for(T e : type.getEnumConstants()) {
+				if(e.name().equals(s)) {
+					set.add(e);
+					break;
+				}
+			}
+		}
+		return set;
+	}
 
 	/**
 	 * Returns whether or not this file is in strict mode. Unlike most options, this one depends on both the file
@@ -71,8 +92,8 @@ public boolean isStrict() {
 		}
 	}
 
-	public boolean isWarningSuppressed(String warning) {
-		return warning.trim().contains(warning.toLowerCase());
+	public boolean isWarningSuppressed(SuppressWarnings warning) {
+		return suppressWarnings.contains(warning);
 	}
 
 	public String getName() {
@@ -101,5 +122,45 @@ public String toString() {
 				+ (description == null ? "" : "File description: " + description + "\n");
 
 	}
+	
+	public static enum SuppressWarnings implements Documentation {
+		// In the future, when some are added, this can be removed, and the rest of the system will work
+		// quite nicely. Perhaps a good first candidate would be to allow string "false" coerced to boolean warning
+		// to be suppressed on a per file basis?
+		Note("There are currently no warning suppressions defined, but some will be added in the future", 
+			CHVersion.V0_0_0);
+
+		private SuppressWarnings(String docs, Version version) {
+			this.docs = docs;
+			this.version = version;
+		}
+		
+		private final String docs;
+		private final Version version;
+		@Override
+		public URL getSourceJar() {
+			return ClassDiscovery.GetClassContainer(this.getClass());
+		}
+
+		@Override
+		public Class<? extends Documentation>[] seeAlso() {
+			return new Class[]{};
+		}
+
+		@Override
+		public String getName() {
+			return this.name();
+		}
+
+		@Override
+		public String docs() {
+			return docs;
+		}
+
+		@Override
+		public Version since() {
+			return version;
+		}
+	}
 
 }

src/main/java/com/laytonsmith/core/constructs/CArray.java

@@ -876,11 +876,11 @@ public int compare(Construct o1, Construct o2) {
 					}
 				}
 				if(o1 instanceof CBoolean || o2 instanceof CBoolean) {
-					if(Static.getBoolean(o1) == Static.getBoolean(o2)) {
+					if(Static.getBoolean(o1, Target.UNKNOWN) == Static.getBoolean(o2, Target.UNKNOWN)) {
 						return 0;
 					} else {
-						int oo1 = Static.getBoolean(o1) ? 1 : 0;
-						int oo2 = Static.getBoolean(o2) ? 1 : 0;
+						int oo1 = Static.getBoolean(o1, Target.UNKNOWN) ? 1 : 0;
+						int oo2 = Static.getBoolean(o2, Target.UNKNOWN) ? 1 : 0;
 						return (oo1 < oo2) ? -1 : 1;
 					}
 				}
@@ -899,13 +899,13 @@ public int compare(Construct o1, Construct o2) {
 			}
 
 			public int compareRegular(Construct o1, Construct o2) {
-				if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1))
-						&& Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2))) {
+				if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1), Target.UNKNOWN)
+						&& Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2), Target.UNKNOWN)) {
 					return compareNumeric(o1, o2);
-				} else if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1))) {
+				} else if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o1), Target.UNKNOWN)) {
 					//The first is a number, the second is a string
 					return -1;
-				} else if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2))) {
+				} else if(Static.getBoolean(new DataHandling.is_numeric().exec(Target.UNKNOWN, null, o2), Target.UNKNOWN)) {
 					//The second is a number, the first is a string
 					return 1;
 				} else {

src/main/java/com/laytonsmith/core/events/Prefilters.java

@@ -152,7 +152,7 @@ private static void ItemMatch(Construct item1, Construct item2) throws Prefilter
 	}
 
 	private static void BooleanMatch(Construct bool1, Construct bool2) throws PrefilterNonMatchException {
-		if(Static.getBoolean(bool1) != Static.getBoolean(bool2)) {
+		if(Static.getBoolean(bool1, Target.UNKNOWN) != Static.getBoolean(bool2, Target.UNKNOWN)) {
 			throw new PrefilterNonMatchException();
 		}
 	}

src/main/java/com/laytonsmith/core/events/drivers/CmdlineEvents.java

@@ -155,7 +155,7 @@ public boolean matches(Map<String, Construct> prefilter, BindableEvent e) throws
 		@Override
 		public BindableEvent convert(CArray manualObject, Target t) {
 			CmdlinePromptInput cpi = new CmdlinePromptInput(manualObject.get("command", t).val(),
-					Static.getBoolean(manualObject.get("shellMode", t)));
+					Static.getBoolean(manualObject.get("shellMode", t), t));
 			return cpi;
 		}
 

src/main/java/com/laytonsmith/core/events/drivers/PlayerEvents.java

@@ -1300,10 +1300,10 @@ public boolean modifyEvent(String key, Construct value, BindableEvent event) {
 						e.setDeathMessage(value.nval());
 						return true;
 					case "keep_inventory":
-						e.setKeepInventory(Static.getBoolean(value));
+						e.setKeepInventory(Static.getBoolean(value, Target.UNKNOWN));
 						return true;
 					case "keep_level":
-						e.setKeepLevel(Static.getBoolean(value));
+						e.setKeepLevel(Static.getBoolean(value, Target.UNKNOWN));
 						return true;
 					case "new_exp":
 						e.setNewExp(Static.getInt32(value, Target.UNKNOWN));
@@ -2447,7 +2447,7 @@ public boolean modifyEvent(String key, Construct value, BindableEvent event) {
 						return true;
 					}
 				} else if(key.equalsIgnoreCase("signing")) {
-					((MCPlayerEditBookEvent) event).setSigning(Static.getBoolean(value));
+					((MCPlayerEditBookEvent) event).setSigning(Static.getBoolean(value, Target.UNKNOWN));
 					return true;
 				} else {
 					return false;

src/main/java/com/laytonsmith/core/events/drivers/VehicleEvents.java

@@ -301,11 +301,11 @@ public boolean modifyEvent(String key, Construct value, BindableEvent event) {
 			if(event instanceof MCVehicleEnitityCollideEvent) {
 				MCVehicleEnitityCollideEvent e = (MCVehicleEnitityCollideEvent) event;
 				if(key.equals("collide")) {
-					e.setCollisionCancelled(!Static.getBoolean(value));
+					e.setCollisionCancelled(!Static.getBoolean(value, Target.UNKNOWN));
 					return true;
 				}
 				if(key.equals("pickup")) {
-					e.setPickupCancelled(!Static.getBoolean(value));
+					e.setPickupCancelled(!Static.getBoolean(value, Target.UNKNOWN));
 					return true;
 				}
 			}