Try to document every single method...

Author: JaciBrunning

src/main/java/jaci/openrio/toast/core/Environment.java

@@ -1,23 +1,54 @@
 package jaci.openrio.toast.core;
 
+/**
+ * The Environment Class is used as a set of hooks to obtain data regarding the Environment the Robot is working in.
+ * This is where modules should check for Verification/Simulated environments, check if FMS is attached, as well as
+ * operated depending on the Operating System the Robot or Simulation is present in.
+ *
+ * @author Jaci
+ */
 public class Environment {
 
+    /**
+     * Is this a Verification Environment? A Verification Environment is launched with args --verify to test
+     * the Robot's behaviour in a generic competition (15 sec Auto, 2 min Teleop). All state changes are done
+     * in this mode, and any uncaught exceptions render the build as 'failed'
+     */
     public static boolean isVerification() {
         return ToastBootstrap.isVerification;
     }
 
+    /**
+     * Is this a Simulation Environment? A Simulation Environment is launched with args --sim (--search) as a
+     * means for Developers to test their code in their IDE without having a robot present. This is used very commonly,
+     * and in most cases all the Class Patching is done for you, but special cases may require this hook.
+     */
     public static boolean isSimulation() {
         return ToastBootstrap.isSimulation;
     }
 
+    /**
+     * Is this an Embedded Environment? Embedded environments are simply described as 'non-simulation' environments, and
+     * are therefore assumed to be running on the NI RoboRIO or standard FRC competition computer onboard the Robot. The
+     * only time a robot program is embedded is when it has been deployed to a robot and is running.
+     */
     public static boolean isEmbedded() {
         return !isSimulation();
     }
 
+    /**
+     * Is this a competition? This returns true if the Robot and Driver Station have adequate communication to the
+     * Field Management System (FMS). This is NOT a substitute for {@link #isEmbedded()}, as the program can be
+     * both embedded and not connected to FMS during times when an FRC regulation field is not present.
+     */
     public static boolean isCompetition() {
         return Toast.getToast().station().isFMSAttached();
     }
 
+    /**
+     * Get the Environmental Type in String form. This formats {@link #isSimulation()}, {@link #isVerification()} and
+     * {@link #isEmbedded()} into their String form for writing to a console or other human-readable resources.
+     */
     public static String getEnvironmentalType() {
         if (isVerification())
             return "Verification";
@@ -28,26 +59,52 @@ else if (isEmbedded())
         return "Unknown";
     }
 
+    /**
+     * Get the architecture of the Operating System. This usually contains x86, 32 or 64 bit systems depending on the
+     * OS.
+     */
     public static String getOS_Architecture() {
         return System.getProperty("os.arch");
     }
 
+    /**
+     * Get the OS Name. This returns things such as 'Linux', 'Mac OS X' or 'Windows'. Best practise is to use .contains()
+     * on the return value, as Windows contains the version number (7, 8, 8.1, 10) in this String and uses os.version
+     * as the build ID.
+     */
     public static String getOS_Name() {
         return System.getProperty("os.name");
     }
 
+    /**
+     * Get the Operating System version. On Mac, this is the OS version such as 10.10, while on Windows this is the OS
+     * build number such as 6.3. This changes per system, so it is most useful in Crash Logs and debugging.
+     */
     public static String getOS_Version() {
         return System.getProperty("os.version");
     }
 
+    /**
+     * Get the Java Vendor. This is usually 'Oracle Corporation' or something similar, unless the user is using some
+     * bootleg version of Java they got from the shady guy in the street called 'Big Moe'
+     */
     public static String getJava_vendor() {
         return System.getProperty("java.vendor");
     }
 
+    /**
+     * Get the Java Version. This follows the standard '1.8.0_33' system. This should be prefixed with '1.8.x_', otherwise
+     * chances are Java is out of date and Toast won't work properly. Update 25 or above is usually required for Groovy
+     * to work.
+     */
     public static String getJava_version() {
         return System.getProperty("java.version");
     }
 
+    /**
+     * Get the Java Home Directory. This is the location of the JRE and JDK. This is used to keep track of System .jar
+     * files present on the system to make sure we don't load them for Module candidacy.
+     */
     public static String getJava_home() {
         return System.getProperty("java.home");
     }

src/main/java/jaci/openrio/toast/core/StateTracker.java

@@ -168,6 +168,9 @@ public static void removeTransition(StateListener.Transition transition) {
         transitioners.removeConcurrent(transition);
     }
 
+    /**
+     * Waits for new control data to be received.
+     */
     private static boolean nextPeriodReady() {
         return impl.station().isNewControlData();
     }

src/main/java/jaci/openrio/toast/core/Toast.java

@@ -118,6 +118,9 @@ public void startCompetition() {
         }
     }
 
+    /**
+     * Register the Garbage Collector to trigger on a regular basis.
+     */
     void registerGC(final double time) {
         Heartbeat.add(new HeartbeatListener() {
             int count = 0;
@@ -132,13 +135,22 @@ public void onHeartbeat(int skipped) {
         });
     }
 
+    /**
+     * Shutdown the robot safely with exit code 0. This will stop all motors and
+     * ensure all actions on the ThreadPool are completed
+     */
     public void shutdownSafely() {
         log().info("Robot Shutting Down...");
         ToastThreadPool.INSTANCE.finish();
         MotorRegistry.stopAll();
         System.exit(0);
     }
 
+    /**
+     * Shutdown the robot when the exit code should not be 0. This is usually when
+     * the robot has crashed or encountered and error. This will forcefully stop the ThreadPool,
+     * all motors and yield the exit code -1
+     */
     public void shutdownCrash() {
         log().info("Robot Error Detected... Shutting Down...");
         ToastThreadPool.INSTANCE.getService().shutdownNow();

src/main/java/jaci/openrio/toast/core/ToastConfiguration.java

@@ -12,12 +12,19 @@ public class ToastConfiguration {
 
     static GroovyPreferences preferences;
 
+    /**
+     * Initialize the Configuration. This creates the Preferences file
+     * and all the properties required.
+     */
     public static void init() {
         preferences = new GroovyPreferences("Toast");
         for (Property prop : Property.values())
             prop.read(preferences);
     }
 
+    /**
+     * Jet fuel can't melt steel beams.
+     */
     public static void jetfuel() {
         String fuel = Property.JET_FUEL.asString();
         if (!fuel.equalsIgnoreCase("steel beams"))
@@ -56,34 +63,59 @@ public static enum Property {
             this.comments = MathHelper.splitStringByWords(comment, 15);
         }
 
+        /**
+         * Read the property from the GroovyPreferences file, with the default value and comments
+         * if it doesn't exist.
+         */
         public void read(GroovyPreferences preferences) {
             value = preferences.getObject(key, defaultValue, comments);
         }
 
+        /**
+         * Get the property as a Number object
+         */
         public Number asNumber() {
-            return (Number) defaultValue;
+            return (Number) value;
         }
 
+        /**
+         * Get the property, casted to an Integer
+         */
         public int asInt() {
             return asNumber().intValue();
         }
 
+        /**
+         * Get the property casted to a Double
+         */
         public double asDouble() {
             return asNumber().doubleValue();
         }
 
+        /**
+         * Get the property, casted to a Float
+         */
         public float asFloat() {
             return asNumber().floatValue();
         }
 
+        /**
+         * Get the property, casted to a Byte
+         */
         public byte asByte() {
             return asNumber().byteValue();
         }
 
+        /**
+         * Get the property in String form
+         */
         public String asString() {
             return (String) value;
         }
 
+        /**
+         * Get the property as a boolean.
+         */
         public boolean asBoolean() {
             return (boolean) value;
         }

src/main/java/jaci/openrio/toast/core/command/AbstractCommand.java

@@ -12,7 +12,6 @@ public abstract class AbstractCommand {
 
     /**
      * Get the command name
-     *
      * e.g. 'cmd' for a command such as 'cmd <your args>
      */
     public abstract String getCommandName();

src/main/java/jaci/openrio/toast/core/command/CommandBus.java

@@ -22,13 +22,20 @@ public class CommandBus {
     public static List<AbstractCommand> commands = new Vector<>();
     public static List<FuzzyCommand> parsers = new Vector<>();
 
+    /**
+     * Start the command bus. This is done by Toast, this shouldn't be triggered by Modules.
+     * This also starts the Simulation Scanner to listen from an IDE's console
+     */
     public static void init() {
         if (ToastBootstrap.isSimulation)
             setupSim();
 
         registerNatives();
     }
 
+    /**
+     * Register the default commands that come with Toast by default.
+     */
     private static void registerNatives() {
         registerCommand(new CommandGroovyScript());
         registerCommand(new CommandUSB());
@@ -147,6 +154,9 @@ public static boolean messageRequested() {
         return nextLineRequested;
     }
 
+    /**
+     * Setup the simulation environment scanner for the IDE's console
+     */
     private static void setupSim() {
         scanner = new Scanner(System.in);
         t = new Thread() {

src/main/java/jaci/openrio/toast/core/command/IHelpable.java

@@ -10,7 +10,6 @@ public interface IHelpable {
 
     /**
      * Get the command name
-     *
      * e.g. 'cmd' for a command such as 'cmd <your args>
      */
     public String getCommandName();

src/main/java/jaci/openrio/toast/core/command/UsageException.java

@@ -15,10 +15,16 @@ public UsageException(String usage) {
         this.usage = usage;
     }
 
+    /**
+     * Get the usage of the command related to the Exception
+     */
     public String getUsage() {
         return usage;
     }
 
+    /**
+     * Get the message of the exception used in logging.
+     */
     public String getMessage() {
         return "Invalid command usage. " + usage;
     }

src/main/java/jaci/openrio/toast/core/command/cmd/CommandExit.java

@@ -9,15 +9,31 @@
  * @author Jaci
  */
 public class CommandExit extends AbstractCommand {
+
+    /**
+     * Get the command name
+     * e.g. 'cmd' for a command such as 'cmd <your args>
+     */
     @Override
     public String getCommandName() {
         return "exit";
     }
 
+    /**
+     * Returns the 'alias' for the command (other names)
+     */
     public String[] getAlias() {
         return new String[] {"quit", ":q"};
     }
 
+    /**
+     * Invoke the command if the name matches the one to be triggered
+     * @param argLength The amount of arguments in the 'args' param
+     * @param args The arguments the command was invoked with. This can be empty if
+     *             none were provided. Keep in mind this does NOT include the Command Name.
+     *             Args are separated by spaces
+     * @param command The full command message
+     */
     @Override
     public void invokeCommand(int argLength, String[] args, String command) {
         Toast.getToast().shutdownSafely();

src/main/java/jaci/openrio/toast/core/command/cmd/CommandGroovyScript.java

@@ -19,11 +19,20 @@
  * @author Jaci
  */
 public class CommandGroovyScript extends FuzzyCommand implements IHelpable {
+
+    /**
+     * Should this Command be invoked with the given message?
+     */
     @Override
     public boolean shouldInvoke(String message) {
         return message.startsWith("script ") || message.startsWith("script -c");
     }
 
+    /**
+     * Invokes the command if {@link #shouldInvoke} returns true.
+     * @param message The full command message. This is left un-parsed so you can handle
+     *                it yourself
+     */
     @Override
     public void invokeCommand(String message) {
         try {
@@ -52,11 +61,18 @@ public void run() {
         }
     }
 
+    /**
+     * Get the command name
+     * e.g. 'cmd' for a command such as 'cmd <your args>
+     */
     @Override
     public String getCommandName() {
         return "script";
     }
 
+    /**
+     * Returns a help message to display with the 'help' command
+     */
     @Override
     public String getHelp() {
         return "Executes a groovy script on-the-fly. Run with -c to execute concurrently. Example: \"script -c println 'Hello World'\"";