feat(function-entry): added function entry

Author: elodszopos

packages/function-entry/configure/src/feedback-mapper.js

@@ -8,8 +8,8 @@ export const modelToFeedbackConfig = model => {
     correctFeedbackType: correctFeedback.type || 'default',
     incorrectFeedback: incorrectFeedback.value,
     incorrectFeedbackType: incorrectFeedback.type || 'default',
-  }
-}
+  };
+};
 
 export const feedbackConfigToModel = (config, model) => {
 
@@ -18,11 +18,12 @@ export const feedbackConfigToModel = (config, model) => {
   model.correctResponse.feedback = {
     type: config.correctFeedbackType,
     value: config.correctFeedback
-  }
+  };
 
   model.incorrectFeedback = {
     type: config.incorrectFeedbackType,
     value: config.incorrectFeedback
-  }
+  };
+
   return model;
-}
+};

packages/function-entry/controller/.babelrc

@@ -0,0 +1,6 @@
+{
+  "presets": [
+    "env",
+    "stage-0"
+  ]
+}

packages/function-entry/controller/__test__/index.test.js

@@ -0,0 +1,116 @@
+import { model } from '../src/index';
+
+
+describe('model', () => {
+
+
+  let result, question, session, env;
+
+  const mkQuestion = () => ({
+    model: {
+      ignoreSpacing: true,
+    },
+    correctResponse: {
+      equation: '3x+2',
+      feedback: {
+        type: 'default'
+      }
+    },
+    incorrectFeedback: {
+      type: 'custom',
+      value: 'foo'
+    }
+  });
+
+  describe('gather', () => {
+
+    beforeEach(async () => {
+      question = mkQuestion();
+      session = { value: '3x+2' };
+      env = { mode: 'gather' };
+      result = await model(question, session, env);
+    });
+
+    it('returns color_contrast', () => {
+      expect(result.colorContrast).toEqual('black_on_white');
+    });
+
+    it('returns disabled:false', () => {
+      expect(result.disabled).toEqual(false);
+    });
+
+    it('returns undefined for correctness ', () => {
+      expect(result.correctness).toEqual(undefined);
+    });
+
+    it('returns undefined for feedback', () => {
+      expect(result.feedback).toEqual(undefined);
+    });
+
+  });
+
+  describe('view', () => {
+
+    beforeEach(async () => {
+      question = mkQuestion();
+      session = { value: '3x+2' };
+      env = { mode: 'view' };
+      result = await model(question, session, env);
+    });
+
+    it('returns disabled:true', () => {
+      expect(result.disabled).toEqual(true);
+    });
+
+    it('returns undefined for correctness ', () => {
+      expect(result.correctness).toEqual(undefined);
+    });
+
+    it('returns default correct for feedback', () => {
+      expect(result.feedback).toEqual(undefined);
+    });
+
+  });
+
+  describe('evaluate - correct', () => {
+    beforeEach(async () => {
+      question = mkQuestion();
+      session = { value: '3x+2' };
+      env = { mode: 'evaluate' };
+      result = await model(question, session, env);
+    });
+
+    it('returns disabled:true', () => {
+      expect(result.disabled).toEqual(true);
+    });
+
+    it('returns correct for correctness ', () => {
+      expect(result.correctness).toEqual('correct');
+    });
+
+    it('returns default correct for feedback', () => {
+      expect(result.feedback).toEqual('Correct');
+    });
+  });
+
+  describe('evaluate - incorrect', () => {
+    beforeEach(async () => {
+      question = mkQuestion();
+      session = { value: '3x+3' };
+      env = { mode: 'evaluate' };
+      result = await model(question, session, env);
+    });
+
+    it('returns disabled:true', () => {
+      expect(result.disabled).toEqual(true);
+    });
+
+    it('returns incorrect for incorrectness ', () => {
+      expect(result.correctness).toEqual('incorrect');
+    });
+
+    it('returns custom incorrect for feedback', () => {
+      expect(result.feedback).toEqual('foo');
+    });
+  });
+});

packages/function-entry/controller/package.json

@@ -2,10 +2,19 @@
   "name": "@pie-element/function-entry-controller",
   "version": "1.0.0",
   "description": "",
-  "main": "src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "./node_modules/.bin/jest"
   },
   "author": "",
-  "license": "ISC"
-}
+  "license": "ISC",
+  "main": "src/index.js",
+  "dependencies": {
+    "debug": "^3.1.0"
+  },
+  "devDependencies": {
+    "jest": "^22.4.0",
+    "babel-jest": "^22.4.0",
+    "babel-preset-env": "^1.6.1",
+    "babel-preset-stage-0": "^6.24.1"
+  }
+}

packages/function-entry/controller/src/index.js

@@ -1,5 +1,79 @@
+import debug from 'debug';
+
+const log = debug('@pie-element:function-entry:controller');
+
+const process = (v, ignoreWhitespace) => {
+    let out = v ? v.trim() : '';
+    out = !ignoreWhitespace ? out : out.replace(/ /g, '');
+    return out;
+};
+
+const isResponseCorrect = (correctResponse, model, value) => {
+    const processedValue = process(value, model.ignoreSpacing);
+
+    return processedValue  === correctResponse;
+};
+
 export function model(question, session, env) {
-  return Promise.resolve({
-    disabled: env.mode !== 'gather'
-  });
-}
+    return new Promise((resolve) => {
+
+        const {model, correctResponse} = question;
+
+        const defaultFeedback = Object.assign({
+            correct: 'Correct',
+            incorrect: 'Incorrect',
+            empty: 'The answer is empty'
+        }, question.defaultFeedback);
+
+        const getFeedback = (correctness) => {
+
+            const fb = (config) => {
+                config = config || {};
+                if (config.type === 'custom') {
+                    return config.value;
+                } else if (config.type === 'default') {
+                    return 'Correct';
+                }
+            };
+
+            if (env.mode === 'evaluate') {
+
+                if (correctness === 'correct') {
+                    return fb(question.correctResponse.feedback, defaultFeedback.correct);
+                }
+
+                if (correctness === 'incorrect') {
+                    return fb(question.incorrectFeedback, defaultFeedback.incorrect);
+                }
+
+                if (correctness === 'empty') {
+                    return defaultFeedback.empty;
+                }
+            }
+        };
+
+        const getCorrectness = () => {
+            if (env.mode === 'evaluate') {
+
+                if (!session.value) {
+                    return 'empty';
+                }
+
+                return isResponseCorrect(correctResponse.equation, model, session.value) ? 'correct' : 'incorrect';
+            }
+        };
+
+
+        const correctness = getCorrectness();
+        const base = {
+            colorContrast: 'black_on_white',
+            correctness,
+            feedback: getFeedback(correctness),
+            disabled: env.mode !== 'gather'
+        };
+
+        const out = Object.assign(base, model);
+        log('out: ', out);
+        resolve(out);
+    });
+}