Rename some config classes.

Change-Id: Ieaa7897a5e0bf1168e5c2b4405585558e108ee52
Reviewed-on: http://gerrit.dmdirc.com/2781
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Build Manager

src/com/dmdirc/config/ConfigSource.java → src/com/dmdirc/config/BaseConfigProvider.java

 import javax.inject.Provider;
 
 /**
- * Defines methods to get options from a config source in various forms.
- * <p>
- * This implementation supports the idea of optional/disabled settings.
+ * Defines methods to get options from a config provider 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
+ *
+ * <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}.
  */
-public abstract class ConfigSource implements ReadOnlyConfigProvider {
+public abstract class BaseConfigProvider implements ReadOnlyConfigProvider {
 
     /** A permissive validator to use when callers don't specify one. */
     private static final Validator<String> PERMISSIVE_VALIDATOR
      *
      * @param colourManager The colour manager to use to convert colours.
      */
-    public ConfigSource(final Provider<ColourManager> colourManager) {
+    public BaseConfigProvider(final Provider<ColourManager> colourManager) {
         this.colourManager = colourManager;
     }
 
      * @deprecated Should pass in a {@link ColourManager}.
      */
     @Deprecated
-    public ConfigSource() {
+    public BaseConfigProvider() {
         this(ColourManager.getColourManagerProvider());
     }
 

src/com/dmdirc/config/Identity.java → src/com/dmdirc/config/ConfigFileBackedConfigProvider.java

 import lombok.extern.slf4j.Slf4j;
 
 /**
- * An identity is a group of settings that are applied to a connection, server,
- * network or channel. Identities may be automatically applied in certain
- * cases, or the user may manually apply them.
- * <p>
- * Note: this class has a natural ordering that is inconsistent with equals.
+ * Provides configuration settings from a {@link ConfigFile}.
  */
 @Slf4j
-public class Identity extends ConfigSource implements ConfigProvider {
+public class ConfigFileBackedConfigProvider extends BaseConfigProvider implements ConfigProvider {
 
     /** The domain used for identity settings. */
     private static final String DOMAIN = "identity";
      * @throws InvalidIdentityFileException Missing required properties
      * @throws IOException Input/output exception
      */
-    public Identity(final File file, final boolean forceDefault) throws IOException,
+    public ConfigFileBackedConfigProvider(final File file, final boolean forceDefault) throws IOException,
             InvalidIdentityFileException {
         super();
 
      * @throws InvalidIdentityFileException Missing required properties
      * @throws IOException Input/output exception
      */
-    public Identity(final InputStream stream, final boolean forceDefault) throws IOException,
+    public ConfigFileBackedConfigProvider(final InputStream stream, final boolean forceDefault) throws IOException,
             InvalidIdentityFileException {
         super();
 
      * @param configFile The config file to use
      * @param target The target of this identity
      */
-    public Identity(final ConfigFile configFile, final ConfigTarget target) {
+    public ConfigFileBackedConfigProvider(final ConfigFile configFile, final ConfigTarget target) {
         super();
 
         this.file = configFile;
     /** {@inheritDoc} */
     @Override
     public boolean equals(final Object obj) {
-        return obj instanceof Identity
-                && getName().equals(((Identity) obj).getName())
-                && getTarget() == ((Identity) obj).getTarget();
+        return obj instanceof ConfigFileBackedConfigProvider
+                && getName().equals(((ConfigFileBackedConfigProvider) obj).getName())
+                && getTarget() == ((ConfigFileBackedConfigProvider) obj).getTarget();
     }
 
 }

src/com/dmdirc/config/ConfigManager.java

  */
 @Slf4j
 @SuppressWarnings("PMD.UnusedPrivateField")
-public class ConfigManager extends ConfigSource implements ConfigChangeListener,
+public class ConfigManager extends BaseConfigProvider implements ConfigChangeListener,
         ConfigProviderListener, AggregateConfigProvider {
 
     /** Temporary map for lookup stats. */

src/com/dmdirc/config/IdentityManager.java

         addonSettings.put("name", "Addon defaults");
         addonConfigFile.addDomain("identity", addonSettings);
 
-        addonConfig = new Identity(addonConfigFile, target);
+        addonConfig = new ConfigFileBackedConfigProvider(addonConfigFile, target);
         addConfigProvider(addonConfig);
 
         if (!getGlobalConfiguration().hasOptionString("identity", "defaultsversion")) {
     private void loadIdentity(final File file) {
         synchronized (identities) {
             for (ConfigProvider identity : getAllIdentities()) {
-                if ((identity instanceof Identity) && ((Identity) identity).isFile(file)) {
+                if ((identity instanceof ConfigFileBackedConfigProvider) && ((ConfigFileBackedConfigProvider) identity).isFile(file)) {
                     // TODO: This manager should keep a list of files->identities instead of
                     //       relying on the identities remembering.
                     try {
         }
 
         try {
-            addConfigProvider(new Identity(file, false));
+            addConfigProvider(new ConfigFileBackedConfigProvider(file, false));
         } catch (InvalidIdentityFileException ex) {
             Logger.userError(ErrorLevel.MEDIUM,
                     "Invalid identity file: " + file.getAbsolutePath()
     @Override
     public void loadVersionIdentity() {
         try {
-            versionConfig = new Identity(IdentityManager.class.getResourceAsStream("/com/dmdirc/version.config"), false);
+            versionConfig = new ConfigFileBackedConfigProvider(IdentityManager.class.getResourceAsStream("/com/dmdirc/version.config"), false);
             addConfigProvider(versionConfig);
         } catch (IOException | InvalidIdentityFileException ex) {
             Logger.appError(ErrorLevel.FATAL, "Unable to load version information", ex);
                 file.createNewFile();
             }
 
-            config = new Identity(file, true);
+            config = new ConfigFileBackedConfigProvider(file, true);
             config.setOption("identity", "name", "Global config");
             addConfigProvider(config);
         } catch (IOException ex) {
      * @throws InvalidIdentityFileException If the settings are invalid
      * @since 0.6.3m1
      */
-    protected Identity createIdentity(final Map<String, Map<String, String>> settings)
+    protected ConfigFileBackedConfigProvider createIdentity(final Map<String, Map<String, String>> settings)
             throws IOException, InvalidIdentityFileException {
         if (!settings.containsKey(IDENTITY_DOMAIN) || !settings.get(IDENTITY_DOMAIN).containsKey("name")
                 || settings.get(IDENTITY_DOMAIN).get("name").isEmpty()) {
 
         configFile.write();
 
-        final Identity identity = new Identity(file, false);
+        final ConfigFileBackedConfigProvider identity = new ConfigFileBackedConfigProvider(file, false);
         addConfigProvider(identity);
 
         return identity;

src/com/dmdirc/plugins/PluginInfo.java

 
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.CoreActionType;
-import com.dmdirc.config.Identity;
+import com.dmdirc.config.ConfigFileBackedConfigProvider;
 import com.dmdirc.config.IdentityManager;
 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.interfaces.config.ConfigProvider;
 
                 synchronized (configProviders) {
                     try {
-                        final ConfigProvider configProvider = new Identity(stream, false);
+                        final ConfigProvider configProvider = new ConfigFileBackedConfigProvider(stream, false);
                         IdentityManager.getIdentityManager().addConfigProvider(configProvider);
                         configProviders.add(configProvider);
                     } catch (final InvalidIdentityFileException ex) {

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

 
 package com.dmdirc.ui.themes;
 
-import com.dmdirc.config.Identity;
+import com.dmdirc.config.ConfigFileBackedConfigProvider;
 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.util.validators.Validator;
 
  * An identity that only claims to know about settings under the UI domain,
  * for use with themes.
  */
-public class ThemeIdentity extends Identity {
+public class ThemeIdentity extends ConfigFileBackedConfigProvider {
 
     /**
      * A version number for this class. It should be changed whenever the class

test/com/dmdirc/config/IdentityTest.java

 
 public class IdentityTest {
 
-    private Identity myIdent;
+    private ConfigFileBackedConfigProvider myIdent;
     private ConfigTarget target;
 
     @Before
         target = new ConfigTarget();
         target.setChannel("#unittest@unittest");
 
-        myIdent = new Identity(new ConfigFile(getClass().getResourceAsStream("identity2")), target);
+        myIdent = new ConfigFileBackedConfigProvider(new ConfigFile(getClass().getResourceAsStream("identity2")), target);
     }
 
     @Test
 
         myIdent.save();
 
-        myIdent = new Identity(myIdent.file.getFile(), false);
+        myIdent = new ConfigFileBackedConfigProvider(myIdent.file.getFile(), false);
 
         assertEquals("baz!", myIdent.getOption("foo", "bar"));
     }
 
     @Test(expected=InvalidIdentityFileException.class)
     public void testNoName() throws IOException, InvalidIdentityFileException {
-        new Identity(getClass().getResourceAsStream("identity1"), false);
+        new ConfigFileBackedConfigProvider(getClass().getResourceAsStream("identity1"), false);
     }
 
     @Test(expected=InvalidIdentityFileException.class)
     public void testNoTarget() throws IOException, InvalidIdentityFileException {
-        new Identity(getClass().getResourceAsStream("identity2"), false);
+        new ConfigFileBackedConfigProvider(getClass().getResourceAsStream("identity2"), false);
     }
 
     @Test
     public void testMigrate() throws IOException, InvalidIdentityFileException {
-        final Identity id = new Identity(getClass().getResourceAsStream("identity3"), false);
+        final ConfigFileBackedConfigProvider id = new ConfigFileBackedConfigProvider(getClass().getResourceAsStream("identity3"), false);
 
         assertTrue(id.file.isKeyDomain("identity"));
         assertTrue(id.file.isKeyDomain("meep"));

test/com/dmdirc/harness/TestConfigSource.java

 
 package com.dmdirc.harness;
 
-import com.dmdirc.config.ConfigSource;
+import com.dmdirc.config.BaseConfigProvider;
 import com.dmdirc.util.validators.Validator;
 
 import java.util.Map;
 
-public class TestConfigSource extends ConfigSource {
+public class TestConfigSource extends BaseConfigProvider {
 
     @Override
     public boolean hasOption(String domain, String option, Validator<String> validator) {