Remove usage of lodash _.reject and _.compact.

Relates to #68.

src/parse/grammar/checks.ts

@@ -261,7 +261,7 @@ namespace chevrotain.checks {
                     return null
                 }
             })
-            return errors.concat(_.compact(currErrors))
+            return errors.concat(utils.compact(currErrors))
         }, [])
 
         return errors

src/scan/lexer.ts

@@ -17,7 +17,7 @@ namespace chevrotain {
 
     export function analyzeTokenClasses(tokenClasses:TokenConstructor[]):IAnalyzeResult {
 
-        let onlyRelevantClasses = _.reject(tokenClasses, (currClass) => {
+        let onlyRelevantClasses = utils.reject(tokenClasses, (currClass) => {
             return currClass[PATTERN] === Lexer.NA
         })
 
@@ -192,7 +192,7 @@ namespace chevrotain {
             }, [])
         })
 
-        identicalPatterns = _.compact(identicalPatterns)
+        identicalPatterns = utils.compact(identicalPatterns)
 
         let duplicatePatterns = utils.filter(identicalPatterns, (currIdenticalSet) => {
             return currIdenticalSet.length > 1

src/utils/utils.ts

@@ -100,6 +100,10 @@ namespace chevrotain.utils {
         return result
     }
 
+    export function reject<T>(arr:T[], predicate:(T) => boolean):T[] {
+        return filter(arr, (item) => !predicate(item))
+    }
+
     export function has(obj:any, prop:string):boolean {
         return obj.hasOwnProperty(prop)
     }
@@ -156,4 +160,8 @@ namespace chevrotain.utils {
         }
         return accumulator
     }
+
+    export function compact<T>(arr:T[]):T[] {
+        return reject(arr, (item) => item === null || item === undefined)
+    }
 }

test/utils/utils_spec.ts

@@ -52,6 +52,15 @@ namespace chevrotain.utils.spec {
             expect(filter(null, (item) => {return item % 2 === 1})).to.deep.equal([])
         })
 
+        it("exports a reject utility", () => {
+            expect(reject([], (item) => {return true})).to.deep.equal([])
+            expect(reject([1, 2, 3], (item) => {return false})).to.deep.equal([1, 2, 3])
+            expect(reject([1, 2, 3], (item) => {return true})).to.deep.equal([])
+            expect(reject([1, 2, 3], (item) => {return item % 2 === 0})).to.deep.equal([1, 3])
+            expect(reject([1, 2, 3], (item) => {return item % 2 === 1})).to.deep.equal([2])
+            expect(reject(null, (item) => {return item % 2 === 1})).to.deep.equal([])
+        })
+
         it("exports a has utility", () => {
             expect(has([1, 2, 3], "0")).to.be.true
             expect(has([1, 2, 3], "5")).to.be.false
@@ -97,6 +106,13 @@ namespace chevrotain.utils.spec {
                 return result.concat([item * 2])
             }, [])).to.deep.equal([2, 4, 6])
         })
+
+        it("exports a compact utility", () => {
+            expect(compact([1, 2, null, 3])).to.deep.equal([1, 2, 3])
+            expect(compact([1, undefined, 2, 3])).to.deep.equal([1, 2, 3])
+            expect(compact([])).to.deep.equal([])
+            expect(compact([1, 2, 3])).to.deep.equal([1, 2, 3])
+        })
     })
 }