feat: implement StateMemoizer which will help us to remember config set via ITerminalOptions

Close #14

Author: mvysny

src/main/java/com/flowingcode/vaadin/addons/xterm/PreserveStateAddon.java

@@ -1,11 +1,18 @@
 package com.flowingcode.vaadin.addons.xterm;
 
+import com.flowingcode.vaadin.addons.xterm.utils.StateMemoizer;
+import lombok.experimental.Delegate;
+
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 
 /**
  * Add-on which preserves the client-side state when the component is removed
- * from the UI then reattached later on.
+ * from the UI then reattached later on. The problem here is that when the
+ * {@link XTerm} server-side component is detached from the UI, the xterm.js client-side
+ * component is destroyed along with its state. When the {@link XTerm} component
+ * is later re-attached to the UI, a new unconfigured xterm.js is created on the
+ * client-side.
  * <p></p>
  * To use this addon, simply create the addon then make sure to call all {@link ITerminal}
  * and {@link ITerminalOptions} methods via this addon:
@@ -16,19 +23,49 @@
  * addon.write("$ ");
  * </pre>
  */
-public class PreserveStateAddon implements ITerminal {
-    private final XTermBase xterm;
+public class PreserveStateAddon implements ITerminal, ITerminalOptions {
+    /**
+     * The xterm to delegate all calls to.
+     */
+    private final XTerm xterm;
+    /**
+     * Remembers everything that was printed into the xterm and what the user typed in.
+     */
     private final StringBuilder scrollbackBuffer = new StringBuilder();
     /**
      * All commands are properly applied before the first attach; they're just
      * not preserved after subsequent detach/attach.
      */
     private boolean wasDetachedOnce = false;
+    /**
+     * Used to re-apply all options to the xterm after it has been reattached back to the UI.
+     * Otherwise, the options would not be applied to the client-side xterm.js component.
+     */
+    private final StateMemoizer optionsMemoizer;
+
+    /**
+     * Delegate all option setters through this delegate, which is the {@link #optionsMemoizer} proxy.
+     * That will allow us to re-apply the settings when the xterm is re-attached.
+     * <p></p>
+     * For example, calling {@link ITerminalOptions#setBellSound(String)}
+     * on this addon will pass through the call to this delegate, which in turn passes
+     * the call to {@link #optionsMemoizer} which remembers the call and passes
+     * it to {@link #xterm}.
+     * <p></p>
+     * After the xterm.js is re-attached, we simply call {@link StateMemoizer#apply()}
+     * to apply all changed setters again to xterm.js, to make sure xterm.js is
+     * configured.
+     */
+    @Delegate
+    private final ITerminalOptions optionsDelegate;
 
     public PreserveStateAddon(XTerm xterm) {
         this.xterm = Objects.requireNonNull(xterm);
+        optionsMemoizer = new StateMemoizer(xterm, ITerminalOptions.class);
+        optionsDelegate = (ITerminalOptions) optionsMemoizer.getProxy();
         xterm.addAttachListener(e -> {
             if (wasDetachedOnce) {
+                optionsMemoizer.apply();
                 xterm.write(scrollbackBuffer.toString());
             }
         });

src/main/java/com/flowingcode/vaadin/addons/xterm/utils/StateMemoizer.java

@@ -0,0 +1,70 @@
+package com.flowingcode.vaadin.addons.xterm.utils;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Remembers the values passed to all setters. At any time you can reapply
+ * those calls by using {@link #apply()}.
+ */
+public class StateMemoizer implements Serializable {
+    /**
+     * Remember all calls to all setters; also remember what args were passed to those setters.
+     */
+    private final Map<String, Serializable> setterCalls = new HashMap<>();
+    /**
+     * Pass-through the setters here.
+     */
+    private final Object delegate;
+    /**
+     * Setters invoked on this proxy will have the args remembered; the methods invocations
+     * will then be passed on to {@link #delegate}.
+     */
+    private final Object proxy;
+
+    /**
+     * Creates the memoizer. Remember to invoke interface methods via {@link #getProxy()} in
+     * order for this to work.
+     * @param delegate pass-through the setters here.
+     * @param interfaces used to create the memoizing proxy.
+     */
+    public StateMemoizer(Object delegate, Class<?>... interfaces) {
+        this.delegate = Objects.requireNonNull(delegate);
+        proxy = Proxy.newProxyInstance(interfaces[0].getClassLoader(), interfaces, (proxy, method, args) -> {
+            if (method.getName().startsWith("set") && args.length == 1) {
+                // remember the state
+                setterCalls.put(method.getName(), (Serializable) args[0]);
+            }
+            return method.invoke(delegate, args);
+        });
+    }
+
+    /**
+     * Setters invoked on this proxy will have the args remembered; the methods invocations
+     * will then be passed on to {@link #delegate}.
+     * @return the proxy, not null.
+     */
+    public Object getProxy() {
+        return proxy;
+    }
+
+    /**
+     * Calls all setters again on {@link #delegate}.
+     */
+    public void apply() {
+        setterCalls.forEach((k, v) -> {
+            final Method method = Arrays.stream(delegate.getClass().getMethods()).filter(it -> it.getName().equals(k)).findAny().get();
+            try {
+                method.invoke(delegate, v);
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+}

src/test/java/com/flowingcode/vaadin/addons/xterm/utils/StateMemoizerTest.java

@@ -0,0 +1,97 @@
+package com.flowingcode.vaadin.addons.xterm.utils;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class StateMemoizerTest {
+
+    private StateMemoizer memoizer;
+    private BunchOfSetters proxy;
+    private MyBean bean;
+
+    public static interface BunchOfSetters {
+        void setFoo(String value);
+        void setBar(int value);
+    }
+
+    public static class MyBean implements BunchOfSetters {
+        private String foo;
+        private int bar;
+
+        public String getFoo() {
+            return foo;
+        }
+
+        public void setFoo(String foo) {
+            this.foo = foo;
+        }
+
+        public int getBar() {
+            return bar;
+        }
+
+        public void setBar(int bar) {
+            this.bar = bar;
+        }
+    }
+
+    @Before
+    public void setupTestValues() {
+        bean = new MyBean();
+        memoizer = new StateMemoizer(bean, BunchOfSetters.class);
+        proxy = (BunchOfSetters) memoizer.getProxy();
+    }
+
+    @Test
+    public void emptyMemoizerApplySucceedsButDoesNothing() {
+        memoizer.apply();
+        assertNull(bean.getFoo());
+        assertEquals(0, bean.getBar());
+    }
+
+    @Test
+    public void proxyModificationPassesValuesThrough() {
+        proxy.setFoo("foo");
+        assertEquals("foo", bean.getFoo());
+        proxy.setBar(25);
+        assertEquals(25, bean.getBar());
+    }
+
+    @Test
+    public void applyAppliesInvokedSettersOnly() {
+        proxy.setFoo("foo");
+        bean.setFoo("bar");
+        bean.setBar(25);
+        memoizer.apply();
+        assertEquals("foo", bean.getFoo());
+        assertEquals(25, bean.getBar());
+    }
+
+    @Test
+    public void applyBasicTest() {
+        proxy.setFoo("foo");
+        proxy.setBar(25);
+        bean.setFoo("FOO");
+        bean.setBar(26);
+        memoizer.apply();
+        assertEquals("foo", bean.getFoo());
+        assertEquals(25, bean.getBar());
+    }
+
+    @Test
+    public void consequentSetterCallsAppliedProperly() {
+        proxy.setFoo("foo");
+        assertEquals("foo", bean.getFoo());
+        proxy.setFoo("bar");
+        assertEquals("bar", bean.getFoo());
+        proxy.setBar(25);
+        bean.setFoo("FOO");
+        bean.setBar(26);
+        memoizer.apply();
+        assertEquals("bar", bean.getFoo());
+        assertEquals(25, bean.getBar());
+    }
+}