feat(core): Make addEntry test pass

Author: parmentf

packages/core/__tests__/core.js

@@ -1,6 +1,35 @@
 'use strict';
 
-import * as CNS from '../src/core';
+import * as ECTOR from '../src/core';
 
 describe('@ector/core', () => {
+    describe('addEntry', () => {
+        it('should in the model', () => {
+            expect(ECTOR.addEntry({
+                username: 'Guy'
+            }, `Hello.`))
+            .toEqual({
+                name: 'ECTOR',
+                username: 'Guy',
+                cn: {
+                    node: [{
+                        label: 'sHello.',
+                        occ: 1
+                    }, {
+                        label: 'wHello.',
+                        occ: 1
+                    }],
+                    link: [{ from: 0, to: 1, coOcc: 1 }]
+                },
+                cns: {
+                    Guy: {
+                        'sHello.': { value: 100 },
+                        'wHello.': { value: 100 }
+                     }
+                },
+                lastSentenceLabel: 'sHello.',
+                lastTokenLabels: ['wHello.']
+            })
+        });
+    });
 });

packages/core/package-lock.json

@@ -36,5 +36,8 @@
     "url": "https://github.com/parmentf/ector-monorepo/issues"
   },
   "dependencies": {
+    "@ector/concept-network": "1.0.2",
+    "@ector/state": "1.0.0",
+    "sentence-tokenizer": "1.0.1"
   }
 }

packages/core/package.json

@@ -1,13 +1,91 @@
 'use strict';
 
+import Tokenizer from 'sentence-tokenizer';
+import { ConceptNetwork, addLink, addNode } from '@ector/concept-network';
+import { ConceptNetworkState, activate } from '@ector/state';
+
+/**
+ * @typedef {Object<string, any>} ECTOR
+ * @property {string}   [name]          name of the bot
+ * @property {string}   [username]      name of the user
+ * @property {ConceptNetwork}       [cn]
+ * @property {Object<string, ConceptNetworkState>}  [cns]   One state per
+ *                                                          username
+ * @property {string}   [lastSentenceLabel] Label of the last entry first sentence
+ * @property {string[]} [lastTokenLabels]   Labels of the last entry tokens
+ */
+
+/**
+ * Add an entry to ector's model.
+ *
+ * @export
+ * @param {ECTOR} ector
+ * @param {string} entry
+ * @returns {ECTOR|Error}
+ */
 export function addEntry(ector, entry) {
+    if (!entry) return new Error('addEntry: No entry given!');
 
-}
+    const name = ector.name || 'ECTOR';
+    const username = ector.username || 'Guy';
+    let cn = ector.cn || {};
+    let cns = ector.cns || {};
+    let state = cns[username] || {};
+    cns = { ...cns, [username]: state };
 
-export function generateResponse(ector) {
+    const tokenizer = new Tokenizer(username, name);
+    tokenizer.setEntry(entry);
+    const sentences = tokenizer.getSentences();
+    let prevSentenceLabel;
+    let lastSentenceLabel = ector.lastSentenceLabel;
 
-}
+    const lastTokenLabels = sentences.reduce(
+        (labels, sentence, sentenceIndex) => {
+            const sentenceLabel = `s${sentence}`;
+            cn = addNode(cn, sentenceLabel);
+            if (prevSentenceLabel) {
+                cn = addLink(cn, prevSentenceLabel, sentenceLabel);
+            }
+            if (sentenceIndex === 0) {
+                lastSentenceLabel = sentenceLabel;
+            }
+            state = activate(state, sentenceLabel);
 
-export function getResponse(ector) {
+            const tokens = tokenizer.getTokens(sentenceIndex);
+            let prevTokenLabel;
+            const tokenLabels = tokens.reduce(
+                (tokenLabels, token, _tokenIndex) => {
+                    const tokenLabel = `w${token}`;
+                    cn = addNode(cn, tokenLabel);
+                    state = activate(state, tokenLabel);
+                    // TODO: add position in sentence (beg, mid, end)
+                    cn = addLink(cn, sentenceLabel, tokenLabel);
+                    if (prevTokenLabel) {
+                        cn = addLink(cn, prevTokenLabel, tokenLabel);
+                    }
+                    prevTokenLabel = tokenLabel;
+                    return [...tokenLabels, tokenLabel];
+                },
+                [],
+            );
+            return [...labels, ...tokenLabels];
+        },
+        [],
+    );
 
+    cns[username] = state;
+    const newEctor = {
+        ...ector,
+        name,
+        username,
+        cn,
+        cns,
+        lastSentenceLabel,
+        lastTokenLabels,
+    };
+    return Object.freeze(newEctor);
 }
+
+export function generateResponse(ector) {}
+
+export function getResponse(ector) {}