New actions substitutor.

Squashed commit of the following:

commit 81c3cb41fe
Author: Chris Smith <chris@dmdirc.com>
Date:   Sun Feb 28 21:13:03 2010 +0000

    Fix a couple of escaping edge cases

    Change-Id: I8cd9c3493a932039b7bae704c522f79778946d55

commit cde2d943dc
Author: Chris Smith <chris@dmdirc.com>
Date:   Thu Feb 25 05:51:38 2010 +0000

    Working actions substitutor replacement

    Fixes issue 3804

    Change-Id: Id714c47d599815461826f403942bfe490ac587ff

commit f450ce592a
Author: Chris Smith <chris@dmdirc.com>
Date:   Thu Feb 25 00:01:55 2010 +0000

    Support for config and server substitutions

    Change-Id: I0b10332f340212d05ac478d4025ee557d2e66351

commit 4d2357a28f
Author: Chris Smith <chris@dmdirc.com>
Date:   Tue Feb 23 21:41:54 2010 +0000

    Implement word and component substitutions

    Change-Id: I120f50e6eec3dc968beff42d79c0171a5908155e

commit 0bb9fbb970
Author: Chris Smith <chris@dmdirc.com>
Date:   Mon Jan 25 21:32:00 2010 +0000

    Unit test for actions substitutor

Change-Id: I4d8b2084f7b78cf2b30f0409e1a7fdfe5a9ee5aa
Reviewed-on: http://gerrit.dmdirc.com/927
Automatic-Compile: DMDirc Local Commits <dmdirc@googlemail.com>
Reviewed-by: Gregory Holmes <greg@dmdirc.com>

src/com/dmdirc/actions/ActionSubstitutor.java

@@ -27,14 +27,17 @@ import com.dmdirc.actions.interfaces.ActionComponent;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.Precondition;
 import com.dmdirc.Server;
-import com.dmdirc.ServerState;
+import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.IdentityManager;
-
 import com.dmdirc.ui.interfaces.Window;
+
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Handles the substitution of variables into action targets and responses.
@@ -65,19 +68,6 @@ public class ActionSubstitutor {
         return IdentityManager.getGlobalConfig().getOptions("actions").keySet();
     }
     
-    /**
-     * Substitutes in config variables into the specified target.
-     *
-     * @param config The configuration manager to use for options
-     * @param target The StringBuilder to modify
-     * @since 0.6.3m2
-     */
-    private void doConfigSubstitutions(final ConfigManager config, final StringBuilder target) {
-        for (Map.Entry<String, String> option : config.getOptions("actions").entrySet()) {
-            doReplacement(target, "$" + option.getKey(), option.getValue());
-        }
-    }
-    
     /**
      * Retrieves a list of substitutions derived from argument and component
      * combinations, along with a corresponding friendly name for them.
@@ -103,33 +93,6 @@ public class ActionSubstitutor {
         return res;
     }
     
-    /**
-     * Substitutes in component-style substitutions.
-     *
-     * @param target The stringbuilder to be changed
-     * @param args The arguments passed for this action type
-     */
-    private void doComponentSubstitutions(final StringBuilder target, final Object ... args) {
-        int i = 0;
-        for (Class myClass : type.getType().getArgTypes()) {
-            if (args[i] != null) {
-                for (ActionComponent comp : ActionManager.getCompatibleComponents(myClass)) {
-                    final String needle = "${" + i + "." + comp.toString() + "}";
-
-                    if (target.indexOf(needle) > -1) {
-                        final Object replacement = comp.get(args[i]);
-
-                        if (replacement != null) {
-                            doReplacement(target, needle, replacement.toString());
-                        }
-                    }
-                }
-            }
-            
-            i++;
-        }
-    }
-    
     /**
      * Retrieves a list of server substitutions, if this action type supports
      * them.
@@ -152,38 +115,6 @@ public class ActionSubstitutor {
         return res;
     }
     
-    /**
-     * Substitutes in server substitutions.
-     *
-     * @param target The stringbuilder to be changed
-     * @param args The arguments passed for this action type
-     */
-    private void doServerSubstitutions(final StringBuilder target, final Object ... args) {
-        if (args.length > 0 && args[0] instanceof FrameContainer) {
-            final Server server = ((FrameContainer) args[0]).getServer();
-        
-            if (server != null) {
-                synchronized (server.getState()) {
-                    if (!server.getState().equals(ServerState.CONNECTED)) {
-                        return;
-                    }
-                    
-                    for (ActionComponent comp : ActionManager.getCompatibleComponents(Server.class)) {
-                        final String key = "${" + comp.toString() + "}";
-
-                        if (target.indexOf(key) > -1) {
-                            final Object res = comp.get(((FrameContainer) args[0]).getServer());
-
-                            if (res != null) {
-                                doReplacement(target, key, res.toString());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
     /**
      * Returns true if this action type's first argument is a frame container,
      * or descendent of one.
@@ -212,42 +143,8 @@ public class ActionSubstitutor {
      */
     public boolean usesWordSubstitutions() {
         return type.getType().getArgTypes().length > 2
-                && type.getType().getArgTypes()[2] == String[].class;
-    }
-    
-    /**
-     * Substitutes in word substitutions.
-     *
-     * @param target The stringbuilder to be changed
-     * @param args The arguments passed for this action type
-     */
-    private void doWordSubstitutions(final StringBuilder target, final Object ... args) {
-        if (args.length > 1) {
-            String[] words = null;
-            
-            if (args.length > 2 && args[2] instanceof String[]) {
-                words = (String[]) args[2];
-            } else if (args.length > 2 && args[2] instanceof String) {
-                words = ((String) args[2]).split(" ");
-            } else if (args[1] instanceof String[]) {
-                words = (String[]) args[1];
-            } else if (args[1] instanceof String) {
-                words = ((String) args[1]).split(" ");
-            } else {
-                return;
-            }
-            
-            final StringBuffer compound = new StringBuffer();
-            for (int i = words.length - 1; i >= 0; i--) {
-                if (compound.length() > 0) {
-                    compound.insert(0, ' ');
-                }
-                compound.insert(0, words[i]);
-                
-                doReplacement(target, "$" + (i + 1) + "-", compound.toString());
-                doReplacement(target, "$" + (i + 1), words[i]);
-            }
-        }
+                && (type.getType().getArgTypes()[2] == String[].class
+                || type.getType().getArgTypes()[2] == String.class);
     }
     
     /**
@@ -268,13 +165,104 @@ public class ActionSubstitutor {
         }
 
         final StringBuilder res = new StringBuilder(target);
-        
-        doConfigSubstitutions(getConfigManager(args), res);
-        doServerSubstitutions(res, args);
-        doComponentSubstitutions(res, args);
-        doWordSubstitutions(res, args);
-        
-        return res.toString();
+
+        final Pattern bracesPattern = Pattern.compile("(?<!\\\\)((?:\\\\\\\\)*)"
+                + "(\\$\\{([^{}]*?)\\})");
+        final Pattern otherPattern = Pattern.compile("(?<!\\\\)((?:\\\\\\\\)*)(\\$("
+                + "[0-9]+(-([0-9]+)?)?|" // Word subs - $1, $1-, $1-2
+                + "[0-9]+(\\.([A-Z_]+))+|" // Component subs - 2.FOO_BAR
+                + "[a-z0-9A-Z_\\.]+" // Config/server subs
+                + "))");
+
+        Matcher bracesMatcher = bracesPattern.matcher(res);
+        Matcher otherMatcher = otherPattern.matcher(res);
+
+        boolean first;
+
+        while ((first = bracesMatcher.find()) || otherMatcher.find()) {
+            final Matcher matcher = first ? bracesMatcher : otherMatcher;
+
+            final String group = matcher.group(3);
+            final int start = matcher.start() + matcher.group(1).length(), end = matcher.end();
+            System.out.println(res + ": " + start + " ->" + end);
+
+            res.delete(start, end);
+            res.insert(start, getSubstitution(doSubstitution(group, args), args));
+            
+            bracesMatcher = bracesPattern.matcher(res);
+            otherMatcher = otherPattern.matcher(res);
+        }
+
+        return res.toString().replaceAll("\\\\(.)", "$1");
+    }
+
+    /**
+     * Retrieves the value which should be used for the specified substitution.
+     *
+     * @param substitution The substitution, without leading $
+     * @param args The arguments for the action
+     * @return The substitution to be used
+     */
+    private String getSubstitution(final String substitution, final Object ... args) {
+        final Pattern numberPattern = Pattern.compile("([0-9]+)(-([0-9]+)?)?");
+        final Matcher numberMatcher = numberPattern.matcher(substitution);
+
+        final Pattern compPattern = Pattern.compile("([0-9]+)\\.([A-Z_]+(\\.[A-Z_]+)*)");
+        final Matcher compMatcher = compPattern.matcher(substitution);
+
+        if (usesWordSubstitutions() && numberMatcher.matches()) {
+            final CommandArguments words = args[2] instanceof String ?
+                new CommandArguments((String) args[2]) :
+                new CommandArguments(Arrays.asList((String[]) args[2]));
+
+            int start, end;
+
+            start = end = Integer.parseInt(numberMatcher.group(1)) - 1;
+
+            if (numberMatcher.group(3) != null) {
+                end = Integer.parseInt(numberMatcher.group(3)) - 1;
+            } else if (numberMatcher.group(2) != null) {
+                end = words.getWords().length - 1;
+            }
+
+            return words.getWordsAsString(start, end);
+        }
+
+        if (compMatcher.matches()) {
+            final int argument = Integer.parseInt(compMatcher.group(1));
+
+            try {
+                final ActionComponentChain chain = new ActionComponentChain(
+                        type.getType().getArgTypes()[argument], compMatcher.group(2));
+                return chain.get(args[argument]).toString();
+            } catch (IllegalArgumentException ex) {
+                // TODO: Log the error nicely somewhere?
+                return substitution;
+            }
+        }
+
+        final ConfigManager manager = getConfigManager(args);
+
+        if (manager.hasOptionString("actions", substitution)) {
+            return manager.getOption("actions", substitution);
+        }
+
+        if (hasFrameContainer()) {
+            final Server server = ((FrameContainer) args[0]).getServer();
+
+            if (server != null) {
+                try {
+                    final ActionComponentChain chain = new ActionComponentChain(
+                        Server.class, substitution);
+                    return chain.get(server).toString();
+                } catch (IllegalArgumentException ex) {
+                    // TODO: Log the error nicely somewhere?
+                    return substitution;
+                }
+            }
+        }
+
+        return substitution;
     }
 
     /**
@@ -299,24 +287,4 @@ public class ActionSubstitutor {
         return IdentityManager.getGlobalConfig();
     }
     
-    /**
-     * Replaces all occurances of needle in haystack with replacement.
-     *
-     * @param haystack The stringbuilder that is to be modified
-     * @param needle The search string
-     * @param replacement The string to be substituted in
-     */
-    private void doReplacement(final StringBuilder haystack, final String needle,
-            final String replacement) {
-        int i = -1;
-        
-        do {
-            i = haystack.indexOf(needle);
-            
-            if (i != -1) {
-                haystack.replace(i, i + needle.length(), replacement);
-            }
-        } while (i != -1);
-    }
-    
 }

test/com/dmdirc/actions/ActionSubstitutorTest.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * 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.actions;
+
+import com.dmdirc.Channel;
+import com.dmdirc.Server;
+import com.dmdirc.ServerState;
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.IdentityManager;
+import com.dmdirc.config.InvalidIdentityFileException;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+@RunWith(Parameterized.class)
+public class ActionSubstitutorTest {
+
+    private static final Map<String, String> settings = new HashMap<String, String>();
+    
+    private final String input, expected;
+    private final Channel channel;
+    private final ActionSubstitutor substitutor;
+    private final Object[] args;
+
+    @BeforeClass
+    public static void setup() throws InvalidIdentityFileException {
+        IdentityManager.load();
+        ActionManager.init();
+
+        settings.put("alpha", "A");
+        settings.put("bravo", "$alpha");
+        settings.put("charlie", "${bravo}");
+        settings.put("delta", "${${bravo}${bravo}}");
+        settings.put("AA", "win!");
+    }
+
+    public ActionSubstitutorTest(final String input, final String expected) {
+        this.input = input;
+        this.expected = expected;
+
+        this.channel = mock(Channel.class);
+        
+        final ConfigManager manager = mock(ConfigManager.class);
+        final Server server = mock(Server.class);
+
+        final ChannelClientInfo clientInfo = mock(ChannelClientInfo.class);
+
+        when(channel.getServer()).thenReturn(server);
+        when(channel.getConfigManager()).thenReturn(manager);
+        when(server.getState()).thenReturn(ServerState.CONNECTED);
+        when(server.getAwayMessage()).thenReturn("foo");
+
+        when(manager.getOptions(eq("actions"))).thenReturn(settings);
+        for (Map.Entry<String, String> entry : settings.entrySet()) {
+            when(manager.hasOptionString("actions", entry.getKey())).thenReturn(true);
+            when(manager.getOption("actions", entry.getKey())).thenReturn(entry.getValue());
+        }
+
+        substitutor = new ActionSubstitutor(CoreActionType.CHANNEL_MESSAGE);
+
+        args = new Object[]{
+            channel,
+            clientInfo,
+            "1 2 3 fourth_word_here 5 6 7"
+        };
+    }
+
+    @Test
+    public void testSubstitution() {
+        assertEquals(expected, substitutor.doSubstitution(input, args));
+    }
+
+    @Parameterized.Parameters
+    public static List<String[]> data() {
+        final String[][] tests = {
+            // -- Existing behaviour -------------------------------------------
+            // ---- No subs at all ---------------------------------------------
+            {"no subs here!", "no subs here!"},
+            // ---- Config subs ------------------------------------------------
+            {"$alpha", "A"},
+            {"--$alpha--", "--A--"},
+            // ---- Word subs --------------------------------------------------
+            {"$1", "1"},
+            {"$4", "fourth_word_here"},
+            {"$5-", "5 6 7"},
+            // ---- Component subs ---------------------------------------------
+            {"${2.STRING_LENGTH}", "28"},
+            {"${2.STRING_STRING}", "1 2 3 fourth_word_here 5 6 7"},
+            // ---- Server subs ------------------------------------------------
+            {"${SERVER_MYAWAYREASON}", "foo"},
+            // ---- Combinations -----------------------------------------------
+            {"${1}${2.STRING_LENGTH}$alpha", "128A"},
+            {"$alpha$4${SERVER_MYAWAYREASON}", "Afourth_word_herefoo"},
+            
+            // -- New behaviour ------------------------------------------------
+            // ---- Config subs ------------------------------------------------
+            {"${alpha}", "A"},
+            {"\\$alpha", "$alpha"},
+            {"$bravo", "A"},
+            {"$charlie", "A"},
+            {"$delta", "win!"},
+            // ---- Word subs --------------------------------------------------
+            {"$5-6", "5 6"},
+            {"${5-6}", "5 6"},
+            {"${5-$6}", "5 6"},
+            {"${5-${${6}}}", "5 6"},
+            // ---- Component subs ---------------------------------------------
+            {"${2.STRING_STRING.STRING_LENGTH}", "28"},
+            // ---- Escaping ---------------------------------------------------
+            {"\\$1", "$1"},
+            {"\\$alpha $alpha", "$alpha A"},
+            {"\\$$1", "$1"},
+            {"\\\\$4", "\\fourth_word_here"},
+            {"\\\\${4}", "\\fourth_word_here"},
+            {"\\\\\\$4", "\\$4"},
+        };
+
+        return Arrays.asList(tests);
+    }
+
+}