Remove usage of _.isEmpty

relates to #68

build/chevrotain.ts

@@ -3,6 +3,8 @@
 /// <reference path="../libs/lodash.d.ts" />
 
 // production code
+/// <reference path="../src/utils/utils.ts" />
+// TODO: move lang --> utils ?
 /// <reference path="../src/lang/lang_extensions.ts" />
 /// <reference path="../src/scan/tokens_public.ts" />
 /// <reference path="../src/scan/lexer_public.ts" />

src/parse/gast_builder.ts

@@ -342,7 +342,7 @@ namespace chevrotain.gastBuilder {
         let parenthesisStack = [1]
 
         let i = -1
-        while (!(_.isEmpty(parenthesisStack)) && i + start < text.length) {
+        while (!(utils.isEmpty(parenthesisStack)) && i + start < text.length) {
             i++
             let nextChar = text.charAt(start + i)
             if (nextChar === opening) {
@@ -354,7 +354,7 @@ namespace chevrotain.gastBuilder {
         }
 
         // valid termination of the search loop
-        if (_.isEmpty(parenthesisStack)) {
+        if (utils.isEmpty(parenthesisStack)) {
             return i + start
         }
         else {

src/parse/grammar/checks.ts

@@ -149,7 +149,7 @@ namespace chevrotain.checks {
                                             path:gast.Rule[] = []):IParserDefinitionError[] {
         let errors = []
         let nextNonTerminals = getFirstNoneTerminal(currRule.definition)
-        if (_.isEmpty(nextNonTerminals)) {
+        if (utils.isEmpty(nextNonTerminals)) {
             return []
         }
         else {
@@ -185,7 +185,7 @@ namespace chevrotain.checks {
 
     export function getFirstNoneTerminal(definition:gast.IProduction[]):gast.Rule[] {
         let result = []
-        if (_.isEmpty(definition)) {
+        if (utils.isEmpty(definition)) {
             return result
         }
         let firstProd = _.first(definition)
@@ -246,7 +246,7 @@ namespace chevrotain.checks {
         let errors = _.reduce(ors, (errors, currOr) => {
             let exceptLast = _.dropRight(currOr.definition)
             let currErrors = _.map(exceptLast, (currAlternative:IProduction, currAltIdx) => {
-                if (_.isEmpty(first.first(currAlternative))) {
+                if (utils.isEmpty(first.first(currAlternative))) {
                     return {
                         message:     `Ambiguous empty alternative: <${currAltIdx + 1}>` +
                                      ` in <OR${currOr.occurrenceInParent}> inside <${topLevelRule.name}> Rule.\n` +

src/parse/grammar/interpreter.ts

@@ -62,7 +62,7 @@ namespace chevrotain.interpreter {
 
         updateExpectedNext():void {
             // need to consume the Terminal
-            if (_.isEmpty(this.ruleStack)) {
+            if (utils.isEmpty(this.ruleStack)) {
                 // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
                 // really seeking is the last Terminal...
                 this.nextProductionName = ""

src/parse/grammar/lookahead.ts

@@ -40,7 +40,7 @@ namespace chevrotain.lookahead {
             checkForOrAmbiguities(alternativesTokens, orOccurrence, ruleGrammar)
         }
 
-        let hasLastAnEmptyAlt = _.isEmpty(_.last(alternativesTokens))
+        let hasLastAnEmptyAlt = utils.isEmpty(_.last(alternativesTokens))
         if (hasLastAnEmptyAlt) {
             let lastIdx = alternativesTokens.length - 1
             /**
@@ -87,7 +87,7 @@ namespace chevrotain.lookahead {
                                           ruleGrammar:gast.Rule):void {
         let altsAmbiguityErrors = checkAlternativesAmbiguities(alternativesTokens)
 
-        if (!_.isEmpty(altsAmbiguityErrors)) {
+        if (!utils.isEmpty(altsAmbiguityErrors)) {
             let errorMessages = _.map(altsAmbiguityErrors, (currAmbiguity) => {
                 return `Ambiguous alternatives: <${currAmbiguity.alts.join(" ,")}> in <OR${orOccurrence}> inside <${ruleGrammar.name}> ` +
                     `Rule, <${tokenName(currAmbiguity.token)}> may appears as the first Terminal in all these alternatives.\n`

src/parse/parser_public.ts

@@ -168,18 +168,18 @@ namespace chevrotain {
                 cache.CLASS_TO_SELF_ANALYSIS_DONE.put(className, true)
                 let validationErrors = checks.validateGrammar(grammarProductions.values())
                 definitionErrors.push.apply(definitionErrors, validationErrors) // mutability for the win?
-                if (!_.isEmpty(definitionErrors) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
+                if (!utils.isEmpty(definitionErrors) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
                     defErrorsMsgs = _.map(definitionErrors, defError => defError.message)
                     throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
                 }
-                if (_.isEmpty(definitionErrors)) { // this analysis may fail if the grammar is not perfectly valid
+                if (utils.isEmpty(definitionErrors)) { // this analysis may fail if the grammar is not perfectly valid
                     let allFollows = follows.computeAllProdsFollows(grammarProductions.values())
                     cache.setResyncFollowsForClass(className, allFollows)
                 }
             }
 
             // reThrow the validation errors each time an erroneous parser is instantiated
-            if (!_.isEmpty(cache.CLASS_TO_DEFINITION_ERRORS.get(className)) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
+            if (!utils.isEmpty(cache.CLASS_TO_DEFINITION_ERRORS.get(className)) && !Parser.DEFER_DEFINITION_ERRORS_HANDLING) {
                 defErrorsMsgs = _.map(cache.CLASS_TO_DEFINITION_ERRORS.get(className), defError => defError.message)
                 throw new Error(`Parser Definition Errors detected\n: ${defErrorsMsgs.join("\n-------------------------------\n")}`)
             }
@@ -283,7 +283,7 @@ namespace chevrotain {
         }
 
         protected isBackTracking():boolean {
-            return !(_.isEmpty(this.isBackTrackingStack))
+            return !(utils.isEmpty(this.isBackTrackingStack))
         }
 
         protected SAVE_ERROR(error:exceptions.IRecognitionException):IRecognitionException {
@@ -1178,7 +1178,7 @@ namespace chevrotain {
             }
 
             // must know the possible following tokens to perform single token insertion
-            if (_.isEmpty(follows)) {
+            if (utils.isEmpty(follows)) {
                 return false
             }
 

src/scan/lexer_public.ts

@@ -110,7 +110,7 @@ namespace chevrotain {
          */
         constructor(protected tokenClasses:TokenConstructor[], deferDefinitionErrorsHandling:boolean = false) {
             this.lexerDefinitionErrors = validatePatterns(tokenClasses)
-            if (!_.isEmpty(this.lexerDefinitionErrors) && !deferDefinitionErrorsHandling) {
+            if (!utils.isEmpty(this.lexerDefinitionErrors) && !deferDefinitionErrorsHandling) {
                 let allErrMessages = _.map(this.lexerDefinitionErrors, (error) => {
                     return error.message
                 })
@@ -121,7 +121,7 @@ namespace chevrotain {
             // If definition errors were encountered, the analysis phase may fail unexpectedly/
             // Considering a lexer with definition errors may never be used, there is no point
             // to performing the analysis anyhow...
-            if (_.isEmpty(this.lexerDefinitionErrors)) {
+            if (utils.isEmpty(this.lexerDefinitionErrors)) {
                 let analyzeResult = analyzeTokenClasses(tokenClasses)
                 this.allPatterns = analyzeResult.allPatterns
                 this.patternIdxToClass = analyzeResult.patternIdxToClass
@@ -151,7 +151,7 @@ namespace chevrotain {
             let column = 1
             let groups:any = _.clone(this.emptyGroups)
 
-            if (!_.isEmpty(this.lexerDefinitionErrors)) {
+            if (!utils.isEmpty(this.lexerDefinitionErrors)) {
                 let allErrMessages = _.map(this.lexerDefinitionErrors, (error) => {
                     return error.message
                 })

src/utils/utils.ts

@@ -0,0 +1,16 @@
+/*
+ Utils using lodash style API. (not necessarily 100% compliant) for functional and other utils.
+ These utils should replace usage of lodash in the production code base. not because they are any better...
+ but for the purpose of being a dependency free library.
+
+ The hotspots in the code are already written in imperative style for performance reasons.
+ so writing several dozen utils which may be slower than the original lodash, does not matter as much
+ considering they will not be invoked in hotspots...
+ */
+
+namespace utils {
+
+    export function isEmpty(arr:any[]) {
+        return arr.length === 0
+    }
+}