Conditional Cases

renderIf.js

@@ -2,5 +2,122 @@
 
 const isFunction = input => typeof input === 'function';
 
-export default predicate => elemOrThunk =>
-  predicate ? (isFunction(elemOrThunk) ? elemOrThunk() : elemOrThunk) : null;
+function renderElemOrThunk (elemOrThunk) {
+  if (isFunction(elemOrThunk)) {
+    return elemOrThunk()
+  }
+  return elemOrThunk;
+}
+
+function renderIf (predicate) {
+  return elemOrThunk => predicate ? renderElemOrThunk(elemOrThunk) : null;
+}
+
+renderIf.if = function multiStatement (initialCondition) {
+  return renderIf.multi().if(initialCondition);
+}
+
+renderIf.switch = function switchStatement (subject) {
+  const cases = [];
+
+  function switchCase (value) {
+    return function switchComponent (elemOrThunk) {
+      cases.push({
+        default: false,
+        elemOrThunk,
+        value
+      });
+
+      return api;
+    }
+  }
+
+  function switchDefault (elemOrThunk) {
+    cases.push({
+      default: true,
+      elemOrThunk
+    });
+
+    return api;
+  }
+
+  function evaluate() {
+    const sortedCase = cases.sort((a, b) => a.default && !b.default);
+
+    for (let i = 0; i < sortedCase.length; i++) {
+      const currentCase = sortedCase[i];
+
+      if (!currentCase.default) {
+        if (currentCase.value === subject) {
+          return renderElemOrThunk(currentCase.elemOrThunk);
+        }
+      } else if (currentCase.default) {
+        return renderElemOrThunk(currentCase.elemOrThunk);
+      }
+    }
+
+    return null;
+  }
+
+  const api = {
+    case: switchCase,
+    default: switchDefault,
+    evaluate
+  };
+
+  return api;
+}
+
+renderIf.multi = function () {
+  const cases = [];
+
+  function createCondition (priority) {
+    return function conditionCase (condition) {
+      return function conditionComponent (elemOrThunk) {
+        cases.push({
+          priority,
+          condition,
+          elemOrThunk
+        });
+
+        return api;
+      }
+    }
+  }
+
+  function elseCondition (elemOrThunk) {
+    cases.push({
+      priority: 2,
+      condition: true,
+      elemOrThunk
+    });
+
+    return api;
+  }
+
+  function evaluate() {
+    let sortedCases = cases.sort((a, b) => a.priority > b.priority);
+
+    for (let i = 0; i < sortedCases.length; i++) {
+      if (sortedCases[i].condition) {
+        if (isFunction(sortedCases[i].elemOrThunk)) {
+          return sortedCases[i].elemOrThunk();
+        }
+        return sortedCases[i].elemOrThunk;
+      }
+    }
+
+    return null;
+  }
+
+  const api = {
+    if: createCondition(0),
+    elseIf: createCondition(1),
+    else: elseCondition,
+    evaluate
+  };
+
+  return api;
+}
+
+export default renderIf;

test.js

@@ -37,4 +37,40 @@ describe('renderIf', () => {
       expect(spy).not.to.have.been.called;
     });
   });
+
+  describe('if/elseIf/else', () => {
+    for (let i = 1; i <= 4; i++) {
+      let result = renderIf.if(i === 1) (
+        '1'
+      ).elseIf(i === 2) (
+        '2'
+      ).elseIf(i === 3) (
+        '3'
+      ).else(
+        '4'
+      ).evaluate();
+
+      expect(result).to.be.equal(`${i}`);
+    }
+  })
+  describe('switch', () => {
+    for (let i = 1; i <= 4; i++) {
+      let result = renderIf.switch(i)
+        .case(1) (
+          '1'
+        )
+        .case(2) (
+          '2'
+        )
+        .case(3) (
+          '3'
+        )
+        .default(
+          '4'
+        )
+        .evaluate();
+
+      expect(result).to.be.eql(`${i}`);
+    }
+  })
 });