Add electron

backend/src/Model/spec/Edge.spec.ts

@@ -0,0 +1,31 @@
+import { Edge, TreeNode } from '../'
+import { expect } from 'chai';
+import 'mocha';
+
+describe('Edge', () => {
+
+  it('should contain a name', () => {
+      let e = new Edge('foo')
+      expect(e.name).to.equal('foo')
+  });
+
+  it('hash should not be empty', () => {
+      let e = new Edge('bar')
+      expect(e.hash().length).to.be.gt(0)
+  });
+
+  it('hash should be stable', () => {
+      let e = new Edge('bar')
+      let previousHash = e.hash()
+      expect(e.hash()).to.eq(previousHash)
+  });
+
+  it('hash should change when parent is present', () => {
+      let foo = new Edge('foo')
+      let bar = new Edge('bar')
+
+      var previousHash = bar.hash()
+      bar.source = new TreeNode(foo, undefined)
+      expect(bar.hash()).to.not.eq(previousHash)
+  });
+});

backend/src/Model/spec/Tree.spec.ts

@@ -0,0 +1,18 @@
+import { Edge, Tree, TreeNode, TreeNodeFactory } from '../'
+import { expect } from 'chai';
+import 'mocha';
+
+import './TreeNode.findNode'
+
+describe('Tree', () => {
+  it('node can be merged into a tree', () => {
+    const tree = new Tree()
+
+    const topics = 'foo/bar'.split('/')
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 3)
+    debugger
+    tree.updateWithNode(leaf.firstNode())
+    let expectedNode = tree.findNode('foo/bar')
+    expect(expectedNode).to.eq(leaf)
+  })
+});

backend/src/Model/spec/TreeNode.findNode.spec.ts

@@ -0,0 +1,29 @@
+import { TreeNode, TreeNodeFactory } from '../'
+import { expect } from 'chai';
+import 'mocha';
+
+import './TreeNode.findNode'
+
+describe('TreeNode.findNode', () => {
+  it('findNode should retrieve node', () => {
+    const topics = 'foo/bar/baz'.split('/')
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 5)
+
+    let root = leaf.firstNode()
+    expect(root.sourceEdge.name).to.eq('')
+
+    let barNode = root.findNode('foo/bar')
+    if (!barNode) {
+      expect.fail('did not find node')
+      return
+    }
+    expect(barNode.sourceEdge.name).to.eq('bar')
+
+    let bazNode = root.findNode('foo/bar/baz')
+    if (!bazNode) {
+      expect.fail('did not find node')
+      return
+    }
+    expect(bazNode.sourceEdge.name).to.eq('baz')
+  })
+})

backend/src/Model/spec/TreeNode.findNode.ts

@@ -0,0 +1,20 @@
+import { TreeNode } from '../'
+
+declare module "../" {
+    interface TreeNode {
+        findNode(path: String): TreeNode | undefined
+    }
+}
+
+TreeNode.prototype.findNode = function(path: String): TreeNode | undefined {
+  const topics = path.split('/')
+  let edge = this.edges[topics[0]]
+  let remainingTopics = topics.slice(1, topics.length)
+  if (edge && remainingTopics.length === 0) {
+    return edge.node
+  } else if (edge) {
+    return edge.node.findNode(remainingTopics.join('/'))
+  }
+
+  return undefined
+}

backend/src/Model/spec/TreeNode.spec.ts

@@ -0,0 +1,51 @@
+import { Edge, Tree, TreeNode, TreeNodeFactory } from '../'
+import { expect } from 'chai';
+import 'mocha';
+
+import './TreeNode.findNode'
+
+describe('TreeNode', () => {
+  it('updateWithNode should update value', () => {
+    const topics = 'foo/bar'.split('/')
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics, 3)
+    expect(leaf.value).to.eq(3)
+    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics, 5)
+    leaf.firstNode().updateWithNode(updateLeave.firstNode())
+
+    expect(leaf.firstNode().sourceEdge.name).to.eq(updateLeave.firstNode().sourceEdge.name)
+    expect(leaf.value).to.eq(5)
+  })
+
+  it('updateWithNode should update intermediate nodes', () => {
+    const topics1 = 'foo/bar/baz'.split('/')
+    const leaf = TreeNodeFactory.fromEdgesAndValue(topics1, 3)
+    expect(leaf.value).to.eq(3)
+
+    const topics2 = 'foo/bar'.split('/')
+    const updateLeave = TreeNodeFactory.fromEdgesAndValue(topics2, 5)
+    leaf.firstNode().updateWithNode(updateLeave.firstNode())
+
+    let barNode = leaf.firstNode().findNode('foo/bar')
+    expect(barNode && barNode.sourceEdge.name).to.eq('bar')
+    expect(barNode && barNode.value).to.eq(5)
+
+    expect(leaf.sourceEdge.name).to.eq('baz')
+    expect(leaf.value).to.eq(3)
+  })
+
+  it('updateWithNode should add nodes to the tree', () => {
+    const topics1 = 'foo/bar'.split('/')
+    const leaf1 = TreeNodeFactory.fromEdgesAndValue(topics1, 3)
+
+    const topics2 = 'foo/bar/baz'.split('/')
+    const leaf2 = TreeNodeFactory.fromEdgesAndValue(topics2, 5)
+
+    leaf1.firstNode().updateWithNode(leaf2.firstNode())
+
+    let expectedNode = leaf1.firstNode().findNode('foo/bar/baz')
+    if (!expectedNode) {
+      expect.fail('merge seems to have failed')
+      return
+    }
+  })
+});

backend/src/Model/spec/TreeNodeFactory.spec.ts

@@ -0,0 +1,46 @@
+import { Edge, TreeNode, TreeNodeFactory } from '../'
+import { expect } from 'chai';
+import 'mocha';
+
+describe('TreeNodeFactory', () => {
+  it('should create node', () => {
+    let topic = 'foo/bar'
+    let edges = topic.split('/')
+    let node = TreeNodeFactory.fromEdgesAndValue(edges, 5)
+
+    expect(node).to.not.eq(undefined)
+    expect(node.sourceEdge.name).to.eq('bar')
+    expect(node.value).to.eq(5)
+
+    if (!node.sourceEdge.source) {
+      expect.fail('should not happen')
+      return
+    }
+
+    let foo = node.sourceEdge.source.sourceEdge
+    expect(foo.name).to.eq('foo')
+  });
+
+  it('node should contain edges in order', () => {
+    let topic = 'foo/bar/baz'
+    let edges = topic.split('/')
+    let node = TreeNodeFactory.fromEdgesAndValue(edges, 5)
+
+    expect(node.value).to.eq(5)
+    expect(node.sourceEdge.name).to.eq('baz')
+
+    const barNode = node.sourceEdge.source
+    if (!barNode) {
+      expect.fail('should not fail')
+      return
+    }
+    expect(barNode.sourceEdge.name).to.eq('bar')
+
+    const fooNode = barNode.sourceEdge.source
+    if (!fooNode) {
+      expect.fail('should not fail')
+      return
+    }
+    expect(fooNode.sourceEdge.name).to.eq('foo')
+  });
+});