[Atom] Create Atom Plugin

plugins/atom/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+    "extends": "airbnb-base",
+    "plugins": [
+        "import"
+    ],
+    "globals": {
+      "atom": false,
+      "document": false,
+    },
+    "rules": {
+      "no-underscore-dangle": "off",
+      "no-plusplus": "off",
+      "no-lonely-if": "off"
+    }
+};

plugins/atom/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+npm-debug.log
+node_modules
+agent
+crdt

plugins/atom/atom_dev_setup.sh

@@ -0,0 +1,28 @@
+#! /bin/bash
+
+SCRIPTPATH=$( cd $(dirname $0) ; pwd -P )
+
+UNINSTALL_OPTION="--uninstall"
+
+function install() {
+  rm -f agent
+  rm -f crdt
+
+  ln -s $SCRIPTPATH/../../agent $SCRIPTPATH
+  ln -s $SCRIPTPATH/../../crdt $SCRIPTPATH
+
+  apm link .
+}
+
+function uninstall() {
+  rm -f agent
+  rm -f crdt
+
+  apm unlink .
+}
+
+if [ "$1" == "$UNINSTALL_OPTION" ] ; then
+  uninstall
+else
+  install
+fi

plugins/atom/lib/connectView.js

@@ -0,0 +1,58 @@
+'use babel';
+
+import { CompositeDisposable, Disposable } from 'atom';
+
+const makeButton = (text, callback) => {
+  const button = document.createElement('button');
+  button.classList.add('btn');
+  button.textContent = text;
+  button.addEventListener('click', callback);
+  return button;
+};
+
+export default class ConnectView {
+  constructor(connectCallback, closeCallback) {
+    this._element = document.createElement('div');
+    this._element.classList.add('tandem-connect-view');
+
+    const label = document.createElement('div');
+    const labelText = document.createElement('span');
+    labelText.textContent = 'Enter an IP and port (e.g. localhost 12345)';
+    label.appendChild(labelText);
+    this._element.appendChild(label);
+
+    const input = document.createElement('input');
+    input.classList.add('input-text');
+    this._element.appendChild(input);
+
+    const okButtonCallback = () => {
+      connectCallback(input.value);
+      input.value = '';
+    };
+    const okButton = makeButton('Connect', okButtonCallback);
+
+    const cancelButtonCallback = () => {
+      closeCallback();
+      input.value = '';
+    };
+    const cancelButton = makeButton('Cancel', cancelButtonCallback);
+
+    this._element.appendChild(okButton);
+    this._element.appendChild(cancelButton);
+
+    this._subscriptions = new CompositeDisposable();
+    this._subscriptions.add(new Disposable(() => {
+      okButton.removeEventListener('click', okButtonCallback);
+      cancelButton.removeEventListener('click', cancelButtonCallback);
+    }));
+  }
+
+  destroy() {
+    this.subscriptions.dispose();
+    this._element.remove();
+  }
+
+  getElement() {
+    return this._element;
+  }
+}

plugins/atom/lib/messages.js

@@ -0,0 +1,176 @@
+'use babel';
+
+const EditorProtocolMessageType = Object.freeze({
+  ApplyText: 'apply-text',
+  ApplyPatches: 'apply-patches',
+  CheckDocumentSync: 'check-document-sync',
+  ConnectTo: 'connect-to',
+  WriteRequest: 'write-request',
+  WriteRequestAck: 'write-request-ack',
+  NewPatches: 'new-patches',
+  UserChangedEditorText: 'user-changed-editor-text',
+});
+
+class ConnectTo {
+  constructor(host, port) {
+    this._type = EditorProtocolMessageType.ConnectTo;
+    this._host = host;
+    this._port = port;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  toPayload() {
+    return {
+      host: this._host,
+      port: this._port,
+    };
+  }
+
+  static fromPayload(payload) {
+    return new ConnectTo(payload.host, payload.port);
+  }
+}
+
+class NewPatches {
+  constructor(patchList) {
+    this._type = EditorProtocolMessageType.NewPatches;
+    this._patchList = patchList;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  toPayload() {
+    return {
+      patch_list: this._patchList,
+    };
+  }
+
+  static fromPayload(payload) {
+    return new NewPatches(payload.patchList);
+  }
+}
+
+class ApplyPatches {
+  constructor(patchList) {
+    this._type = EditorProtocolMessageType.ApplyPatches;
+    this._patchList = patchList;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getPatchList() {
+    return this._patchList;
+  }
+
+  toPayload() {
+    return {
+      patch_list: this._patchList,
+    };
+  }
+
+  static fromPayload(payload) {
+    return new ApplyPatches(payload.patch_list);
+  }
+}
+
+class WriteRequest {
+  constructor(seq) {
+    this._type = EditorProtocolMessageType.WriteRequest;
+    this._seq = seq;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getSeq() {
+    return this._seq;
+  }
+
+  toPayload() {
+    return {
+      seq: this._seq,
+    };
+  }
+
+  static fromPayload(payload) {
+    return new WriteRequest(payload.seq);
+  }
+}
+
+class WriteRequestAck {
+  constructor(seq) {
+    this._type = EditorProtocolMessageType.WriteRequestAck;
+    this._seq = seq;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getSeq() {
+    return this._seq;
+  }
+
+  toPayload() {
+    return {
+      seq: this._seq,
+    };
+  }
+
+  static fromPayload(payload) {
+    return new WriteRequestAck(payload.seq);
+  }
+}
+
+const serialize = message =>
+  JSON.stringify({
+    type: message.getType(),
+    payload: message.toPayload(),
+    version: 1,
+  });
+
+const deserialize = (data) => {
+  try {
+    const { type, payload } = JSON.parse(data);
+
+    switch (type) {
+      case EditorProtocolMessageType.ConnectTo:
+        return ConnectTo.fromPayload(payload);
+
+      case EditorProtocolMessageType.NewPatches:
+        return NewPatches.fromPayload(payload);
+
+      case EditorProtocolMessageType.ApplyPatches:
+        return ApplyPatches.fromPayload(payload);
+
+      case EditorProtocolMessageType.WriteRequest:
+        return WriteRequest.fromPayload(payload);
+
+      case EditorProtocolMessageType.WriteRequestAck:
+        return WriteRequestAck.fromPayload(payload);
+
+      default:
+        throw new Error();
+    }
+  } catch (e) {
+    throw new Error('Deserialization error.');
+  }
+};
+
+export default {
+  ConnectTo,
+  NewPatches,
+  ApplyPatches,
+  WriteRequest,
+  WriteRequestAck,
+  serialize,
+  deserialize,
+};

plugins/atom/lib/tandem.js

@@ -0,0 +1,83 @@
+'use babel';
+
+import { CompositeDisposable } from 'atom';
+import TandemPlugin from './tandemPlugin';
+import ConnectView from './connectView';
+
+export default {
+
+  _tandemAgent: null,
+  _subscriptions: null,
+  _connectPanel: null,
+
+  activate() {
+    this._tandemAgent = new TandemPlugin();
+
+    const connectView = new ConnectView(
+      this._connectToHost.bind(this),
+      () => { this._inputPanel.hide(); },
+    );
+    this._inputPanel = atom.workspace.addModalPanel({
+      item: connectView,
+      visible: false,
+    });
+
+    this._subscriptions = new CompositeDisposable();
+    this._subscriptions.add(atom.commands.add('atom-workspace', {
+      'tandem:join-existing-session': () => this._connect(),
+    }));
+    this._subscriptions.add(atom.commands.add('atom-workspace', {
+      'tandem:start-session': () => this._start(),
+    }));
+    this._subscriptions.add(atom.commands.add('atom-workspace', {
+      'tandem:leave-session': () => this._stop(),
+    }));
+  },
+
+  deactivate() {
+    if (this._tandemAgent && this._tandemAgent.isActive()) {
+      this._tandemAgent.stop();
+    }
+    this._subscriptions.dispose();
+  },
+
+  _getTextEditor(newEditor) {
+    return new Promise((res) => {
+      if (newEditor) {
+        return res(atom.workspace.open());
+      }
+      const editor = atom.workspace.getActiveTextEditor();
+      if (editor) {
+        return res(editor);
+      }
+      // Open a new text editor if one is not open
+      return res(atom.workspace.open());
+    });
+  },
+
+  _start() {
+    this._getTextEditor().then((editor) => {
+      this._tandemAgent.start(editor.getBuffer());
+    });
+  },
+
+  _connect() {
+    this._inputPanel.show();
+  },
+
+  _connectToHost(input) {
+    this._inputPanel.hide();
+
+    const args = input.split(' ');
+    const ip = args[0];
+    const port = args[1];
+
+    this._getTextEditor(/* newEditor */ true).then((editor) => {
+      this._tandemAgent.start(editor.getBuffer(), ip, port);
+    });
+  },
+
+  _stop() {
+    this._tandemAgent.stop();
+  },
+};