Add a GlobalAutoCommandsDialogModel.

src/com/dmdirc/interfaces/ui/GlobalAutoCommandsDialogModel.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.interfaces.ui;
+
+import com.dmdirc.commandparser.auto.AutoCommand;
+import com.dmdirc.util.validators.Validator;
+
+/**
+ * Represents a dialog that can edit the global {@link AutoCommand} in the client.
+ */
+public interface GlobalAutoCommandsDialogModel {
+
+    /**
+     * Loads the model.  This should be called before interacting with the model in any way.
+     */
+    void load();
+
+    /**
+     * Returns the current response to be included in the global {@link AutoCommand}.
+     *
+     * @return Current response.  Will never be null, may be empty.
+     */
+    String getResponse();
+
+    /**
+     * Sets the response to be included in the global {@link AutoCommand}.
+     *
+     * @param response New response.  Should never be null, this may be empty, but the dialog should
+     *                 not try to save whilst it is empty.
+     */
+    void setResponse(final String response);
+
+    /**
+     * Returns the validator for a {@Link AutoCommand}'s response.
+     *
+     * @return Validator for a response string
+     */
+    Validator<String> getResponseValidator();
+
+    /**
+     * Is the current response valid?
+     *
+     * @return true iif the response is valid
+     */
+    boolean isResponseValid();
+
+    /**
+     * Is the dialog allowed to be saved?
+     *
+     * @return true iif the dialog can be saved
+     */
+    boolean isSaveAllowed();
+
+    /**
+     * Saves the current state into the global {@link AutoCommand}.
+     */
+    void save();
+}

src/com/dmdirc/ui/core/autocommands/CoreGlobalAutoCommandsDialogModel.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.ui.core.autocommands;
+
+import com.dmdirc.commandparser.auto.AutoCommand;
+import com.dmdirc.commandparser.auto.AutoCommandManager;
+import com.dmdirc.commandparser.auto.AutoCommandType;
+import com.dmdirc.interfaces.ui.GlobalAutoCommandsDialogModel;
+import com.dmdirc.util.validators.Validator;
+
+import java.util.Optional;
+
+import javax.inject.Inject;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+/**
+ * Basic implementation of an {@link GlobalAutoCommandsDialogModel}.
+ */
+public class CoreGlobalAutoCommandsDialogModel implements GlobalAutoCommandsDialogModel {
+
+    private final AutoCommandManager autoCommandManager;
+    private final ResponseValidator responseValidator;
+    private boolean loaded;
+    private Optional<AutoCommand> globalAutoCommand;
+    private MutableAutoCommand autoCommand;
+
+    @Inject
+    public CoreGlobalAutoCommandsDialogModel(final AutoCommandManager autoCommandManager,
+            final ResponseValidator responseValidator) {
+        this.autoCommandManager = autoCommandManager;
+        this.responseValidator = responseValidator;
+        autoCommand = getAutoCommand(Optional.empty());
+    }
+
+    @Override
+    public void load() {
+        loaded = true;
+        globalAutoCommand = autoCommandManager.getGlobalAutoCommand();
+        autoCommand = getAutoCommand(globalAutoCommand);
+    }
+
+    @Override
+    public String getResponse() {
+        checkState(loaded);
+        return autoCommand.getResponse();
+    }
+
+    @Override
+    public void setResponse(final String response) {
+        checkState(loaded);
+        checkNotNull(response);
+        autoCommand.setResponse(response);
+    }
+
+    @Override
+    public Validator<String> getResponseValidator() {
+        checkState(loaded);
+        return responseValidator;
+    }
+
+    @Override
+    public boolean isResponseValid() {
+        checkState(loaded);
+        return !getResponseValidator().validate(autoCommand.getResponse()).isFailure();
+    }
+
+    @Override
+    public boolean isSaveAllowed() {
+        checkState(loaded);
+        return isResponseValid();
+    }
+
+    @Override
+    public void save() {
+        checkState(loaded);
+        checkState(isSaveAllowed());
+        if (globalAutoCommand.isPresent()) {
+            autoCommandManager.replaceAutoCommand(globalAutoCommand.get(), getAutoCommand(autoCommand));
+        } else {
+            autoCommandManager.addAutoCommand(getAutoCommand(autoCommand));
+        }
+    }
+
+    private MutableAutoCommand getAutoCommand(final Optional<AutoCommand> command) {
+        if (command.isPresent()) {
+            final AutoCommand c = command.get();
+            return new MutableAutoCommand(c.getServer(),
+                    c.getNetwork(), c.getProfile(), c.getResponse(), c.getType());
+        } else {
+            return new MutableAutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "",
+                    AutoCommandType.GLOBAL);
+        }
+    }
+
+    private AutoCommand getAutoCommand(final MutableAutoCommand command) {
+        return AutoCommand.create(command.getServer(), command.getNetwork(), command.getProfile(),
+                command.getResponse());
+    }
+}

src/com/dmdirc/ui/core/autocommands/ResponseValidator.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.ui.core.autocommands;
+
+import com.dmdirc.commandparser.auto.AutoCommand;
+import com.dmdirc.interfaces.CommandController;
+import com.dmdirc.util.validators.ValidationResponse;
+import com.dmdirc.util.validators.Validator;
+
+import com.google.common.base.Strings;
+
+import javax.inject.Inject;
+
+/**
+ * Validates the response for an {@link AutoCommand}.
+ */
+public class ResponseValidator implements Validator<String> {
+
+    private final String commandChar;
+
+    @Inject
+    public ResponseValidator(final CommandController controller) {
+        commandChar = String.valueOf(controller.getCommandChar());
+    }
+
+    @Override
+    public ValidationResponse validate(final String object) {
+        if (Strings.isNullOrEmpty(object)) {
+            return new ValidationResponse("Response cannot be empty");
+        }
+        for (String line : object.split("\n")) {
+            if (line.startsWith(commandChar)) {
+                return new ValidationResponse("Lines should not start with a command character");
+            }
+        }
+        return new ValidationResponse();
+    }
+}

test/com/dmdirc/ui/core/autocommands/CoreGlobalAutoCommandsDialogModelTest.java

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.ui.core.autocommands;
+
+import com.dmdirc.commandparser.auto.AutoCommand;
+import com.dmdirc.commandparser.auto.AutoCommandManager;
+import com.dmdirc.interfaces.CommandController;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CoreGlobalAutoCommandsDialogModelTest {
+
+    @Mock private AutoCommandManager autoCommandManager;
+    @Mock private CommandController commandController;
+    @Mock private AutoCommand autoCommand;
+    private CoreGlobalAutoCommandsDialogModel instance;
+
+    @Before
+    public void setUp() throws Exception {
+        when(autoCommand.getServer()).thenReturn(Optional.empty());
+        when(autoCommand.getNetwork()).thenReturn(Optional.empty());
+        when(autoCommand.getProfile()).thenReturn(Optional.empty());
+        when(autoCommand.getResponse()).thenReturn("response");
+        when(commandController.getCommandChar()).thenReturn('/');
+        when(autoCommandManager.getGlobalAutoCommand()).thenReturn(Optional.of(autoCommand));
+        instance = new CoreGlobalAutoCommandsDialogModel(autoCommandManager,
+                new ResponseValidator(commandController));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testLoad_NotCalled() throws Exception {
+        instance = new CoreGlobalAutoCommandsDialogModel(autoCommandManager,
+                new ResponseValidator(commandController));
+        instance.getResponse();
+    }
+
+    @Test
+    public void testGetResponse_Empty() throws Exception {
+        when(autoCommandManager.getGlobalAutoCommand()).thenReturn(Optional.empty());
+        instance.load();
+        assertEquals("", instance.getResponse());
+    }
+
+    @Test
+    public void testGetResponse_Complete() throws Exception {
+        instance.load();
+        assertEquals("response", instance.getResponse());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testSetResponse_Null() throws Exception {
+        instance.load();
+        assertEquals("response", instance.getResponse());
+        instance.setResponse(null);
+    }
+
+    @Test
+    public void testSetResponse_empty() throws Exception {
+        instance.load();
+        assertEquals("response", instance.getResponse());
+        instance.setResponse("");
+        assertEquals("", instance.getResponse());
+    }
+
+    @Test
+    public void testSetResponse() throws Exception {
+        instance.load();
+        assertEquals("response", instance.getResponse());
+        instance.setResponse("test");
+        assertEquals("test", instance.getResponse());
+    }
+
+    @Test
+    public void testGetResponseValidator() throws Exception {
+        instance.load();
+        assertNotNull(instance.getResponseValidator());
+    }
+
+    @Test
+    public void testIsResponseValid_Initially() throws Exception {
+        instance.load();
+        assertTrue(instance.isResponseValid());
+    }
+
+    @Test
+    public void testIsResponseValid_EmptyGlobal() throws Exception {
+        when(autoCommandManager.getGlobalAutoCommand()).thenReturn(Optional.empty());
+        instance.load();
+        assertFalse(instance.isResponseValid());
+    }
+
+    @Test
+    public void testIsResponseValid_Empty() throws Exception {
+        instance.load();
+        instance.setResponse("");
+        assertFalse(instance.isResponseValid());
+    }
+
+    @Test
+    public void testIsResponseValid_CommandChar() throws Exception {
+        instance.load();
+        instance.setResponse("/moo");
+        assertFalse(instance.isResponseValid());
+    }
+
+    @Test
+    public void testIsResponseValid() throws Exception {
+        instance.load();
+        instance.setResponse("moo");
+        assertTrue(instance.isResponseValid());
+    }
+
+    @Test
+    public void testIsSaveAllowed_InvalidResponse() throws Exception {
+        instance.load();
+        assertTrue(instance.isSaveAllowed());
+        instance.setResponse("");
+        assertFalse(instance.isSaveAllowed());
+    }
+
+    @Test
+    public void testIsSaveAllowed() throws Exception {
+        instance.load();
+        assertTrue(instance.isSaveAllowed());
+        instance.setResponse("test");
+        assertTrue(instance.isSaveAllowed());
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void testSave_NotAllowed() throws Exception {
+        instance.load();
+        instance.setResponse("");
+        assertFalse(instance.isSaveAllowed());
+        instance.save();
+    }
+
+    @Test
+    public void testSave_EmptyGlobal() throws Exception {
+        when(autoCommandManager.getGlobalAutoCommand()).thenReturn(Optional.empty());
+        instance.load();
+        instance.setResponse("test");
+        assertTrue(instance.isSaveAllowed());
+        instance.save();
+        verify(autoCommandManager).addAutoCommand(eq(AutoCommand.create(Optional.empty(),
+                Optional.empty(), Optional.empty(), "test")));
+    }
+
+    @Test
+    public void testSave() throws Exception {
+        instance.load();
+        instance.setResponse("test");
+        assertTrue(instance.isSaveAllowed());
+        instance.save();
+        verify(autoCommandManager).replaceAutoCommand(eq(autoCommand), eq(AutoCommand
+                .create(Optional.empty(), Optional.empty(), Optional.empty(), "test")));
+    }
+}