feat(range) inclusive

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -100,7 +100,6 @@ const protocols = repositories.map(match({
 }))
 ```
 
-
 ##### Regular Expressions
 
 match-when supports [regular expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) as well:
@@ -114,6 +113,18 @@ match-when supports [regular expressions](https://developer.mozilla.org/en-US/do
 // ['hey.com', 'wat']
 ```
 
+##### Range
+
+```js
+[12, 42, 99, 101].map(match({
+  [when.range(0, 41)]: '< answer',
+  [when.range(43, 100)]: '> answer',
+  [when(42)]: 'answer',
+  [when()]: '< 0, or > 100'
+}));
+
+// ['< answer', 'answer', '> answer', '< 0, or > 100']
+```
 
 ### Supported patterns:
 
@@ -129,7 +140,6 @@ match-when supports [regular expressions](https://developer.mozilla.org/en-US/do
 I will accept PR with their associated tests for the following features:
 
 
-- support `range(x, y)`
 - define and implement some syntax to support wildcards
 - try and maybe support `match(input, {patterns...})` syntax instead of `match({patterns...})(input)`?
 

match.js

@@ -5,6 +5,8 @@ const _patternOR = Symbol('match.pattern.OR');
 const _patternORStr = _patternOR.toString(); // dirty hack
 const _patternAND = Symbol('match.pattern.AND');
 const _patternANDStr = _patternAND.toString(); // dirty hack
+const _patternRANGE = Symbol('match.pattern.RANGE');
+const _patternRANGEStr = _patternRANGE.toString(); // dirty hack
 
 const _patternREGEXP = Symbol('match.pattern.REGEXP');
 const _patternREGEXPStr = _patternREGEXP.toString(); // dirty hack
@@ -77,6 +79,13 @@ function _match(props){
       };
     }
 
+    if(props[0] === _patternRANGEStr){
+      props.shift();
+      return function(input){
+        return props[0] <= input && input <= props[1];
+      };
+    }
+
     if(props[0] === _patternREGEXPStr){
       const res = EXTRACT_PATTERN_AND_FLAGS.exec(props[1]);
       return _matching.bind(null, new RegExp(res[1], res[2]));
@@ -120,6 +129,10 @@ when.and = function(/* args... */){
   return JSON.stringify([_patternAND.toString(), Array.prototype.slice.call(arguments)]);
 };
 
+when.range = function(start, end){
+  return JSON.stringify([_patternRANGE.toString(), start, end]);
+};
+
 when.unserialize = function(props, value){
   return {
     match: props === _catchAllSymbol ? _true : _match(JSON.parse(props)),

match.test.js

@@ -131,6 +131,64 @@ describe('match', () => {
     })
   });
 
+  describe('when.range', () => {
+    const rangeStart = 0,
+      rangeEnd = 5;
+
+    beforeEach(function () {
+      this.withinRange = match({
+        [when.range(rangeStart, rangeEnd)]: true,
+        [when()]: false
+      });
+    });
+
+    describe('given a value within the range', function () {
+      it('should match', function () {
+        t.isTrue(this.withinRange(rangeStart+1));
+      });
+    });
+
+    describe('given a value at the lower bound', function () {
+      it('should match', function () {
+        t.isTrue(this.withinRange(rangeStart));
+      });
+    });
+
+    describe('given a value at the upper bound', function () {
+      it('should match', function () {
+        t.isTrue(this.withinRange(rangeEnd));
+      });
+    });
+
+    describe('given a value above the upper bound', function () {
+      it('should not match', function () {
+        t.isFalse(this.withinRange(rangeEnd+1));
+      });
+    });
+
+    describe('given a value below the lower bound', function () {
+      it('should not match', function () {
+        t.isFalse(this.withinRange(rangeStart-1));
+      });
+    });
+
+    describe('the example in the docs', function () {
+      it('works correctly', function () {
+        var result = [12, 42, 99, 101].map(match({
+          [when.range(0, 41)]: '< answer',
+          [when.range(43, 100)]: '> answer',
+          [when(42)]: 'answer',
+          [when()]: '< 0, or > 100'
+        }));
+
+        var expected = ['< answer', 'answer', '> answer', '< 0, or > 100']
+
+        t.deepEqual(result, expected);
+      });
+    });
+
+  });
+
   describe('yielding', () => {
     it('should also be able to yield primitive values', () => {
       const output = input.map(match({