Rework how config sources handle invalid and disabled settings

Fixes CLIENT-46

Depends-On: I8434b810ba3ee5548467c3fd2b72faed4046a586
Change-Id: I79e9a19acf452c831ee6e671f50b54e8f674f2cd
Reviewed-on: http://gerrit.dmdirc.com/1569
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/config/ConfigManager.java

 
 import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.util.MapList;
+import com.dmdirc.util.validators.Validator;
 
 import java.util.ArrayList;
 import java.util.Collections;
 
     /** {@inheritDoc} */
     @Override
-    public String getOption(final String domain, final String option) {
+    public String getOption(final String domain, final String option,
+            final Validator<String> validator) {
         doStats(domain, option);
 
         synchronized (sources) {
             for (Identity source : sources) {
-                if (source.hasOption(domain, option)) {
-                    return source.getOption(domain, option);
+                if (source.hasOption(domain, option, validator)) {
+                    return source.getOption(domain, option, validator);
                 }
             }
         }
 
-        throw new IllegalArgumentException("Config option not found: " + domain + "." + option);
+        return null;
     }
 
     /** {@inheritDoc} */
     @Override
-    protected boolean hasOption(final String domain, final String option) {
+    protected boolean hasOption(final String domain, final String option,
+            final Validator<String> validator) {
         doStats(domain, option);
 
         synchronized (sources) {
             for (Identity source : sources) {
-                if (source.hasOption(domain, option)) {
+                if (source.hasOption(domain, option, validator)) {
                     return true;
                 }
             }
     protected Identity getScope(final String domain, final String option) {
         synchronized (sources) {
             for (Identity source : sources) {
-                if (source.hasOption(domain, option)) {
+                if (source.hasOptionString(domain, option)) {
                     return source;
                 }
             }

src/com/dmdirc/config/ConfigSource.java

 package com.dmdirc.config;
 
 import com.dmdirc.ui.messages.ColourManager;
+import com.dmdirc.util.validators.ColourValidator;
+import com.dmdirc.util.validators.DisabledOptionValidator;
+import com.dmdirc.util.validators.NumericalValidator;
+import com.dmdirc.util.validators.OptionalValidator;
+import com.dmdirc.util.validators.PermissiveValidator;
+import com.dmdirc.util.validators.Validator;
+import com.dmdirc.util.validators.ValidatorChain;
 
 import java.awt.Color;
 import java.util.ArrayList;
 
 /**
  * Defines methods to get options from a config source in various forms.
+ * <p>
+ * This implementation supports the idea of optional/disabled settings.
+ * This is where values may be prefixed with the strings <code>true:</code>
+ * or <code>false:</code>, where the former has no effect on the value of
+ * the setting, and the latter indicates that the user wishes to disable
+ * the setting.
+ * <p>
+ * Disabled settings allow for optional settings to have default values; a
+ * value can be added with the <code>false:</code> prefix which effectively
+ * disables the default value and makes the setting act as though it does not
+ * have a value. Note that for this sort of behaviour to make sense, it requires
+ * an implementation that takes values from multiple sources, such as a
+ * {@link ConfigManager}.
  *
  * @author chris
  */
 public abstract class ConfigSource {
+    
+    /** A permissive validator to use when callers don't specify one. */
+    private static final Validator<String> PERMISSIVE_VALIDATOR
+            = new PermissiveValidator<String>();
+    
+    /** A validator for integer settings. */
+    private static final Validator<String> INT_VALIDATOR
+            = new OptionalValidator(new NumericalValidator(-1, -1));
+    
+    /** A validator for colour settings. */
+    private static final Validator<String> COLOUR_VALIDATOR
+            = new OptionalValidator(new ColourValidator());
 
     /**
-     * Retrieves the specified option.
+     * Retrieves the specified option from this config source.
      *
      * @param domain The domain of the option
      * @param option The name of the option
-     * @return The value of the option
+     * @return The value of the option, or null if it doesn't exist
      */
-    public abstract String getOption(final String domain, final String option);
+    public String getOption(final String domain, final String option) {
+        return getOption(domain, option, PERMISSIVE_VALIDATOR);
+    }
+    
+    /**
+     * Retrieves the first value for the specified option that matches the
+     * specified validator.
+     *
+     * @since 0.6.5
+     * @param domain The domain of the option
+     * @param option The name of the option
+     * @param validator The validator to use to check legal values
+     * @return The value of the option, or null if no matching values exist
+     */
+    protected abstract String getOption(final String domain,
+            final String option, final Validator<String> validator);
 
     /**
-     * Determines if this manager has the specified option.
+     * Determines if this source has a value for the specified option which
+     * matches the specified validator.
      *
+     * @since 0.6.5
      * @param domain The domain of the option
      * @param option The name of the option
-     * @return True iff the option exists, false otherwise.
+     * @param validator The validator to use to check legal values
+     * @return True iff a matching option exists, false otherwise.
      */
-    protected abstract boolean hasOption(final String domain, final String option);
+    protected abstract boolean hasOption(final String domain,
+            final String option, final Validator<String> validator);
 
     /**
-     * Determines if this manager has the specified String option.
+     * Determines if this source has the specified String option.
+     * <p>
+     * A String option is considered to exist if:
+     * <ul>
+     *  <li>there is a value for the specified option,
+     *  <li>that value is not empty, and
+     *  <li>that value is not disabled (i.e., it doesn't begin with "false:")
+     * </ul>
      *
      * @param domain The domain of the option
      * @param option The name of the option
      * @return True iff the option exists and is not empty, false otherwise
      */
     public boolean hasOptionString(final String domain, final String option) {
+        return hasOptionString(domain, option, PERMISSIVE_VALIDATOR);
+    }
+    
+    /**
+     * Determines if this source has the specified String option.
+     * <p>
+     * A String option is considered to exist if:
+     * <ul>
+     *  <li>there is a value for the specified option that
+     *      satisfies the specified validator,
+     *  <li>that value is not empty, and
+     *  <li>that value is not disabled (i.e., it doesn't begin with "false:")
+     * </ul>
+     *
+     * @param domain The domain of the option
+     * @param option The name of the option
+     * @param validator The validator to use to check legal values
+     * @since 0.6.5
+     * @return True iff the option exists and is not empty, false otherwise
+     */
+    public boolean hasOptionString(final String domain, final String option,
+            final Validator<String> validator) {
         String value;
 
-        return hasOption(domain, option) && !(value = getOption(domain, option)).isEmpty()
+        return hasOption(domain, option, validator)
+                && !(value = getOption(domain, option, validator)).isEmpty()
                 && !value.startsWith("false:");
     }
 
     /**
-     * Determines if this manager has the specified integer option.
+     * Determines if this source has the specified integer option.
      *
      * @param domain The domain of the option
      * @param option The name of the option
      * false otherwise.
      */
     public boolean hasOptionInt(final String domain, final String option) {
-        if (hasOption(domain, option)) {
-            try {
-                return getOptionInt(domain, option) != null;
-            } catch (NumberFormatException ex) {
-                // Do nothing
-            }
-        }
-
-        return false;
+        return hasOptionString(domain, option, INT_VALIDATOR);
     }
 
     /**
-     * Determines if this manager has the specified character option.
+     * Determines if this source has the specified character option.
      *
      * @param domain The domain of the option
      * @param option The name of the option
      * false otherwise.
      */
     public boolean hasOptionChar(final String domain, final String option) {
-        return hasOption(domain, option) && !getOption(domain, option).isEmpty();
+        return hasOptionString(domain, option);
     }
 
     /**
-     * Determines if this manager has the specified colour option.
+     * Determines if this source has the specified colour option.
      *
      * @param domain The domain of the option
      * @param option The name of the option
      * false otherwise.
      */
     public boolean hasOptionColour(final String domain, final String option) {
-        if (hasOption(domain, option)) {
-            String value = getOption(domain, option);
-            String colour;
-
-            if (value.startsWith("true:")) {
-                colour = value.substring(5);
-            } else {
-                colour = value;
-            }
-
-            return ColourManager.parseColour(colour, null) != null;
-        } else {
-            return false;
-        }
+        return hasOptionString(domain, option, COLOUR_VALIDATOR);
     }
 
     /**
      * @return The boolean representation of the option
      */
     public boolean hasOptionBool(final String domain, final String option) {
-        return hasOption(domain, option);
+        return hasOption(domain, option, PERMISSIVE_VALIDATOR);
     }
-
+    
     /**
-     * Retrieves the specified option as a String, if it exists
+     * Retrieves the specified option as a String, if it exists and satisfies
+     * the specified validator.
+     * <p>
+     * If no fallback settings are supplied (or if fallback settings are
+     * supplied and execution reaches the last fallback setting) AND if the
+     * 'required' parameter is true, then all disabled values (i.e., those
+     * starting with <code>false:</code>) will be ignored. To check if a valid
+     * non-disabled value exists, call
+     * {@link #hasOptionString(java.lang.String, java.lang.String, com.dmdirc.util.validators.Validator)}.
      *
      * @param domain The domain of the option
      * @param option The name of the option
+     * @param required Whether the specified option is required or not
+     * @param validator The validator to use to check the value
      * @param fallbacks An ordered array of further domains and options
      * (in pairs) to try if the specified domain/option isn't found
      * @return The string representation of the option or null if optional
      * setting is not specified
-     * @since 0.6.3
+     * @since 0.6.5
      */
     public String getOptionString(final String domain, final String option,
+            final boolean required, final Validator<String> validator,
             final String ... fallbacks) {
         String value;
+        
+        @SuppressWarnings("unchecked")
+        final Validator<String> newValidator = required && fallbacks.length == 0
+                ? new ValidatorChain<String>(new DisabledOptionValidator(), validator)
+                : validator;
 
-        if (!hasOption(domain, option) || (value = getOption(domain, option))
-                .startsWith("false:")) {
-            return fallbacks.length >= 2 ? getOptionString(fallbacks[0], fallbacks[1],
+        if (!hasOption(domain, option, newValidator)
+                || (value = getOption(domain, option, newValidator)).startsWith("false:")) {            
+            return fallbacks.length >= 2 ? getOptionString(fallbacks[0],
+                    fallbacks[1], required, validator,
                     Arrays.copyOfRange(fallbacks, 2, fallbacks.length)) : null;
         } else if (value.startsWith("true:")) {
             return value.substring(5);
         }
     }
 
+    /**
+     * Retrieves the specified option as a String, if it exists.
+     *
+     * @param domain The domain of the option
+     * @param option The name of the option
+     * @param fallbacks An ordered array of further domains and options
+     * (in pairs) to try if the specified domain/option isn't found
+     * @return The string representation of the option or null if optional
+     * setting is not specified
+     * @since 0.6.3
+     */
+    public String getOptionString(final String domain, final String option,
+            final String ... fallbacks) {
+        return getOptionString(domain, option, true, PERMISSIVE_VALIDATOR, fallbacks);
+    }
+
     /**
      * Retrieves the specified option as a character.
      *
      */
     public Color getOptionColour(final String domain, final String option,
             final String ... fallbacks) {
-        final String value = getOptionString(domain, option, fallbacks);
+        final String value = getOptionString(domain, option, true, COLOUR_VALIDATOR, fallbacks);
 
         return value == null ? null : ColourManager.parseColour(value, null);
     }
             final boolean trimEmpty) {
         final List<String> res = new ArrayList<String>();
 
-        if (hasOption(domain, option)) {
+        if (hasOption(domain, option, PERMISSIVE_VALIDATOR)) {
             for (String line : getOption(domain, option).split("\n")) {
                 if (!line.isEmpty() || !trimEmpty) {
                     res.add(line);
     public List<String> getOptionList(final String domain, final String option) {
         return getOptionList(domain, option, true);
     }
-
+    
     /**
      * Retrieves an integral representation of the specified option.
      *
      * @param option The name of the option
      * @param fallbacks An ordered array of further domains and options
      * (in pairs) to try if the specified domain/option isn't found
-     * @throws NumberFormatException If the setting can't be parsed
-     * @return The integer representation of the option or null if optional
-     * setting is false
+     * @return The integer representation of the option
      */
     public Integer getOptionInt(final String domain, final String option,
             final String ... fallbacks) {
-        final String value = getOptionString(domain, option, fallbacks);
+        return getOptionInt(domain, option, true, fallbacks);
+    }
+
+    /**
+     * Retrieves an integral representation of the specified option.
+     *
+     * @since 0.6.5
+     * @param domain The domain of the option
+     * @param option The name of the option
+     * @param required Whether this option is required or optional
+     * @param fallbacks An ordered array of further domains and options
+     * (in pairs) to try if the specified domain/option isn't found
+     * @return The integer representation of the option
+     */
+    public Integer getOptionInt(final String domain, final String option,
+            final boolean required, final String ... fallbacks) {
+        final String value = getOptionString(domain, option, required, INT_VALIDATOR, fallbacks);
 
         return value == null ? null : Integer.parseInt(value.trim());
     }

src/com/dmdirc/config/Identity.java

 import com.dmdirc.util.ConfigFile;
 import com.dmdirc.util.InvalidConfigFileException;
 import com.dmdirc.util.WeakList;
+import com.dmdirc.util.validators.Validator;
 
 import java.io.File;
 import java.io.IOException;
             throws InvalidIdentityFileException {
         final ConfigTarget target = new ConfigTarget();
 
-        if (hasOption(DOMAIN, "ircd")) {
+        if (hasOptionString(DOMAIN, "ircd")) {
             target.setIrcd(getOption(DOMAIN, "ircd"));
-        } else if (hasOption(DOMAIN, "protocol")) {
+        } else if (hasOptionString(DOMAIN, "protocol")) {
             target.setProtocol(getOption(DOMAIN, "protocol"));
-        } else if (hasOption(DOMAIN, "network")) {
+        } else if (hasOptionString(DOMAIN, "network")) {
             target.setNetwork(getOption(DOMAIN, "network"));
-        } else if (hasOption(DOMAIN, "server")) {
+        } else if (hasOptionString(DOMAIN, "server")) {
             target.setServer(getOption(DOMAIN, "server"));
-        } else if (hasOption(DOMAIN, "channel")) {
+        } else if (hasOptionString(DOMAIN, "channel")) {
             target.setChannel(getOption(DOMAIN, "channel"));
-        } else if (hasOption(DOMAIN, "globaldefault")) {
+        } else if (hasOptionString(DOMAIN, "globaldefault")) {
             target.setGlobalDefault();
-        } else if (hasOption(DOMAIN, "global") || (forceDefault && !isProfile())) {
+        } else if (hasOptionString(DOMAIN, "global") || (forceDefault && !isProfile())) {
             target.setGlobal();
         } else if (isProfile()) {
             target.setCustom(PROFILE_DOMAIN);
-        } else if (hasOption(DOMAIN, "type")) {
+        } else if (hasOptionString(DOMAIN, "type")) {
             target.setCustom(getOption(DOMAIN, "type"));
         } else {
             throw new InvalidIdentityFileException("No target and no profile");
         }
 
-        if (hasOption(DOMAIN, "order")) {
+        if (hasOptionString(DOMAIN, "order")) {
             target.setOrder(getOptionInt(DOMAIN, "order"));
         }
 
             throw new InvalidIdentityFileException(ex);
         }
 
-        if (!hasOption(DOMAIN, "name") && !forceDefault) {
+        if (!hasOptionString(DOMAIN, "name") && !forceDefault) {
             throw new InvalidIdentityFileException("No name specified");
         }
     }
      * @return The name of this identity
      */
     public String getName() {
-        if (hasOption(DOMAIN, "name")) {
+        if (hasOptionString(DOMAIN, "name")) {
             return getOption(DOMAIN, "name");
         } else {
             return "Unnamed";
      * @since 0.6.3m1
      */
     protected void migrateProfile() {
-        if (hasOption(PROFILE_DOMAIN, "nickname")) {
+        if (hasOptionString(PROFILE_DOMAIN, "nickname")) {
             // Migrate
 
             setOption(PROFILE_DOMAIN, "nicknames", getOption(PROFILE_DOMAIN, "nickname")
-                    + (hasOption(PROFILE_DOMAIN, "altnicks") ? "\n"
+                    + (hasOptionString(PROFILE_DOMAIN, "altnicks") ? "\n"
                     + getOption(PROFILE_DOMAIN, "altnicks") : ""));
             unsetOption(PROFILE_DOMAIN, "nickname");
             unsetOption(PROFILE_DOMAIN, "altnicks");
      * @return True iff this identity can be used as a profile
      */
     public boolean isProfile() {
-        return (hasOption(PROFILE_DOMAIN, "nicknames")
-                || hasOption(PROFILE_DOMAIN, "nickname"))
-                && hasOption(PROFILE_DOMAIN, "realname");
+        return (hasOptionString(PROFILE_DOMAIN, "nicknames")
+                || hasOptionString(PROFILE_DOMAIN, "nickname"))
+                && hasOptionString(PROFILE_DOMAIN, "realname");
     }
 
     /** {@inheritDoc} */
     @Override
-    protected boolean hasOption(final String domain, final String option) {
-        return file.isKeyDomain(domain) && file.getKeyDomain(domain).containsKey(option);
+    protected boolean hasOption(final String domain, final String option,
+            final Validator<String> validator) {
+        return file.isKeyDomain(domain)
+                && file.getKeyDomain(domain).containsKey(option)
+                && !validator.validate(file.getKeyDomain(domain).get(option)).isFailure();
     }
 
     /** {@inheritDoc} */
     @Override
-    public synchronized String getOption(final String domain, final String option) {
-        return file.getKeyDomain(domain).get(option);
+    public synchronized String getOption(final String domain,
+            final String option, final Validator<String> validator) {
+        final String value = file.getKeyDomain(domain).get(option);
+        
+        if (validator.validate(value).isFailure()) {
+            return null;
+        }
+        
+        return value;
     }
 
     /**
 
                 globalConfig.removeIdentity(this);
 
-                if (globalConfig.hasOption(domain, option)
+                if (globalConfig.hasOptionString(domain, option)
                         && globalConfig.getOption(domain, option).equals(value)) {
                     // The new value is covered by a default setting
                     if (oldValue == null) {
                         final String key = subentry.getKey();
                         final String value = subentry.getValue();
 
-                        if (globalConfig.hasOption(domain, key) &&
+                        if (globalConfig.hasOptionString(domain, key) &&
                                 globalConfig.getOption(domain, key).equals(value)) {
                             LOGGER.log(Level.FINEST,
                                     "{0}: found superfluous setting: {1}.{2} (= {3})",

src/com/dmdirc/ui/messages/ColourManager.java

     private static void initColours() {
         for (int i = 0; i < 16; i++) {
             if (IdentityManager.getGlobalConfig().hasOptionColour("colour", String.valueOf(i))) {
-                ircColours[i] = getColour(IdentityManager.getGlobalConfig()
-                        .getOption("colour", String.valueOf(i)));
+                ircColours[i] = IdentityManager.getGlobalConfig()
+                        .getOptionColour("colour", String.valueOf(i));
                 COLOUR_CACHE.remove(String.valueOf(i));
             } else if (!ircColours[i].equals(DEFAULT_COLOURS[i])) {
                 ircColours[i] = DEFAULT_COLOURS[i];

src/com/dmdirc/ui/messages/IRCDocument.java

 
         cachedLines = new RollingList<Line>(50);
         cachedStrings = new RollingList<AttributedString>(50);
-        frameBufferSize = configManager.getOptionInt("ui", "frameBufferSize");
+        frameBufferSize = configManager.getOptionInt("ui", "frameBufferSize", false);
 
         configManager.addChangeListener("ui", "textPaneFontSize", this);
         configManager.addChangeListener("ui", "textPaneFontName", this);
         } else {
             fontSize = defaultFont.getSize();
         }
-        frameBufferSize = configManager.getOptionInt("ui", "frameBufferSize");
+        frameBufferSize = configManager.getOptionInt("ui", "frameBufferSize", false);
         trim(frameBufferSize);
     }
 

src/com/dmdirc/ui/themes/ThemeIdentity.java

 
 import com.dmdirc.config.Identity;
 import com.dmdirc.config.InvalidIdentityFileException;
+import com.dmdirc.util.validators.Validator;
 
 import java.io.IOException;
 import java.io.InputStream;
 
     /** {@inheritDoc} */
     @Override @Deprecated
-    public boolean hasOption(final String domain, final String option) {
+    public boolean hasOption(final String domain, final String option,
+            final Validator<String> validator) {
         if (domain.equalsIgnoreCase("ui") || domain.equalsIgnoreCase("identity")
                 || domain.equalsIgnoreCase("icon")  || domain.equalsIgnoreCase("theme")
                 || domain.equalsIgnoreCase("formatter") || domain.equalsIgnoreCase("colour")) {
-            return super.hasOption(domain, option);
+            return super.hasOption(domain, option, validator);
         } else {
             return false;
         }
 
     /** {@inheritDoc} */
     @Override
-    public String getOption(final String domain, final String option) {
-        final String result = super.getOption(domain, option);
+    public String getOption(final String domain,
+            final String option, final Validator<String> validator) {
+        final String result = super.getOption(domain, option, validator);
 
         if (result == null) {
             return result;

test/com/dmdirc/config/ConfigManagerTest.java

 package com.dmdirc.config;
 
 import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.util.validators.PermissiveValidator;
 
 import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class ConfigManagerTest {
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test
     public void testNonExistantOption() {
-        new ConfigManager("", "", "", "").getOption("unit-test123", "foobar");
+        assertNull(new ConfigManager("", "", "", "").getOption("unit-test123", "foobar"));
     }
 
     @Test
     public void testStats() {
         final ConfigManager cm = new ConfigManager("", "", "", "");
         assertNull(ConfigManager.getStats().get("unit-test123.baz"));
-        cm.hasOption("unit-test123", "baz");
+        cm.hasOption("unit-test123", "baz", new PermissiveValidator<String>());
         assertNotNull(ConfigManager.getStats().get("unit-test123.baz"));
         assertEquals(1, (int) ConfigManager.getStats().get("unit-test123.baz"));
     }

test/com/dmdirc/config/IdentityTest.java

 package com.dmdirc.config;
 
 import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.util.validators.PermissiveValidator;
 
 import java.io.IOException;
 import java.util.Map;
 
     @Test
     public void testHasOption() {
-        assertFalse(myIdent.hasOption("has", "option"));
+        assertFalse(myIdent.hasOption("has", "option", new PermissiveValidator<String>()));
 
         myIdent.setOption("has", "option", "");
 
-        assertTrue(myIdent.hasOption("has", "option"));
+        assertTrue(myIdent.hasOption("has", "option", new PermissiveValidator<String>()));
 
         myIdent.unsetOption("has", "option");
     }

test/com/dmdirc/harness/TestConfigManagerMap.java

 package com.dmdirc.harness;
 
 import com.dmdirc.config.ConfigManager;
+import com.dmdirc.util.validators.Validator;
 import java.util.HashMap;
 import java.util.Map;
 
     }
 
     @Override @Deprecated
-    public boolean hasOption(String domain, String option) {
+    public boolean hasOption(String domain, String option, Validator<String> validator) {
         if (settings.containsKey(domain + "." + option)) {
             return true;
         } else {
-            return super.hasOption(domain, option);
+            return super.hasOption(domain, option, validator);
         }
     }
 }

test/com/dmdirc/harness/TestConfigManagerOptionToggle.java

 package com.dmdirc.harness;
 
 import com.dmdirc.config.ConfigManager;
+import com.dmdirc.util.validators.Validator;
 
 public class TestConfigManagerOptionToggle extends ConfigManager {
     private static final long serialVersionUID = 8078917248288638755L;
     }
 
     @Override
-    public String getOption(String domain, String option) {
+    public String getOption(String domain, String option, Validator<String> validator) {
         return option.substring(1);
     }
 
     @Override @Deprecated
-    public boolean hasOption(String domain, String option) {
+    public boolean hasOption(String domain, String option, Validator<String> validator) {
         return option.charAt(0) == '1';
     }
 }

test/com/dmdirc/harness/TestConfigSource.java

 package com.dmdirc.harness;
 
 import com.dmdirc.config.*;
+import com.dmdirc.util.validators.Validator;
 
 public class TestConfigSource extends ConfigSource {
 
     @Override
-    public String getOption(String domain, String option) {
-        return option;
+    protected boolean hasOption(String domain, String option, Validator<String> validator) {
+        return Boolean.parseBoolean(domain);
     }
 
     @Override
-    protected boolean hasOption(String domain, String option) {
-        return Boolean.parseBoolean(domain);
+    protected String getOption(String domain, String option, Validator<String> validator) {
+        return option;
     }
 }