Index: graphspell-js/spellchecker.js ================================================================== --- graphspell-js/spellchecker.js +++ graphspell-js/spellchecker.js @@ -37,10 +37,13 @@ } this.oMainDic = this._loadDictionary(mainDic, sPath, true); this.oExtendedDic = this._loadDictionary(extentedDic, sPath); this.oCommunityDic = this._loadDictionary(communityDic, sPath); this.oPersonalDic = this._loadDictionary(personalDic, sPath); + this.bExtendedDic = Boolean(this.oExtendedDic); + this.bCommunityDic = Boolean(this.oCommunityDic); + this.bPersonalDic = Boolean(this.oPersonalDic); this.oTokenizer = null; } _loadDictionary (dictionary, sPath, bNecessary=false) { // returns an IBDAWG object @@ -87,24 +90,58 @@ } setExtendedDictionary (dictionary) { // returns true if the dictionary is loaded this.oExtendedDic = this._loadDictionary(dictionary); - return Boolean(this.oExtendedDic); + this.bExtendedDic = Boolean(this.oExtendedDic); + return this.bExtendedDic; } setCommunityDictionary (dictionary) { // returns true if the dictionary is loaded this.oCommunityDic = this._loadDictionary(dictionary); - return Boolean(this.oCommunityDic); + this.bCommunityDic = Boolean(this.oCommunityDic); + return this.bCommunityDic; } setPersonalDictionary (dictionary) { // returns true if the dictionary is loaded this.oPersonalDic = this._loadDictionary(dictionary); - return Boolean(this.oPersonalDic); + this.bPersonalDic = Boolean(this.oPersonalDic); + return this.bPersonalDic; + } + + activateExtendedDictionary () { + if (this.oExtendedDic) { + this.bExtendedDic = true; + } + } + + activateCommunityDictionary () { + if (this.oCommunityDic) { + this.bCommunityDic = true; + } + } + + activatePersonalDictionary () { + if (this.oPersonalDic) { + this.bPersonalDic = true; + } + } + + deactivateExtendedDictionary () { + this.bExtendedDic = false; + } + + deactivateCommunityDictionary () { + this.bCommunityDic = false; + } + + deactivatePersonalDictionary () { + this.bPersonalDic = false; } + // parse text functions parseParagraph (sText) { if (!this.oTokenizer) { @@ -124,17 +161,17 @@ isValidToken (sToken) { // checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked) if (this.oMainDic.isValidToken(sToken)) { return true; } - if (this.oExtendedDic && this.oExtendedDic.isValidToken(sToken)) { + if (this.bExtendedDic && this.oExtendedDic.isValidToken(sToken)) { return true; } - if (this.oCommunityDic && this.oCommunityDic.isValidToken(sToken)) { + if (this.bCommunityDic && this.oCommunityDic.isValidToken(sToken)) { return true; } - if (this.oPersonalDic && this.oPersonalDic.isValidToken(sToken)) { + if (this.bPersonalDic && this.oPersonalDic.isValidToken(sToken)) { return true; } return false; } @@ -141,17 +178,17 @@ isValid (sWord) { // checks if sWord is valid (different casing tested if the first letter is a capital) if (this.oMainDic.isValid(sWord)) { return true; } - if (this.oExtendedDic && this.oExtendedDic.isValid(sWord)) { + if (this.bExtendedDic && this.oExtendedDic.isValid(sWord)) { return true; } - if (this.oCommunityDic && this.oCommunityDic.isValid(sToken)) { + if (this.bCommunityDic && this.oCommunityDic.isValid(sToken)) { return true; } - if (this.oPersonalDic && this.oPersonalDic.isValid(sWord)) { + if (this.bPersonalDic && this.oPersonalDic.isValid(sWord)) { return true; } return false; } @@ -158,64 +195,64 @@ lookup (sWord) { // checks if sWord is in dictionary as is (strict verification) if (this.oMainDic.lookup(sWord)) { return true; } - if (this.oExtendedDic && this.oExtendedDic.lookup(sWord)) { + if (this.bExtendedDic && this.oExtendedDic.lookup(sWord)) { return true; } - if (this.oCommunityDic && this.oCommunityDic.lookup(sToken)) { + if (this.bCommunityDic && this.oCommunityDic.lookup(sToken)) { return true; } - if (this.oPersonalDic && this.oPersonalDic.lookup(sWord)) { + if (this.bPersonalDic && this.oPersonalDic.lookup(sWord)) { return true; } return false; } getMorph (sWord) { // retrieves morphologies list, different casing allowed let lResult = this.oMainDic.getMorph(sWord); - if (this.oExtendedDic) { + if (this.bExtendedDic) { lResult.push(...this.oExtendedDic.getMorph(sWord)); } - if (this.oCommunityDic) { + if (this.bCommunityDic) { lResult.push(...this.oCommunityDic.getMorph(sWord)); } - if (this.oPersonalDic) { + if (this.bPersonalDic) { lResult.push(...this.oPersonalDic.getMorph(sWord)); } return lResult; } * suggest (sWord, nSuggLimit=10) { // generator: returns 1, 2 or 3 lists of suggestions yield this.oMainDic.suggest(sWord, nSuggLimit); - if (this.oExtendedDic) { + if (this.bExtendedDic) { yield this.oExtendedDic.suggest(sWord, nSuggLimit); } - if (this.oCommunityDic) { + if (this.bCommunityDic) { yield this.oCommunityDic.suggest(sWord, nSuggLimit); } - if (this.oPersonalDic) { + if (this.bPersonalDic) { yield this.oPersonalDic.suggest(sWord, nSuggLimit); } } * select (sPattern="") { // generator: returns all entries which morphology fits yield* this.oMainDic.select(sPattern) - if (this.oExtendedDic) { + if (this.bExtendedDic) { yield* this.oExtendedDic.select(sPattern); } - if (this.oCommunityDic) { + if (this.bCommunityDic) { yield* this.oCommunityDic.select(sPattern); } - if (this.oPersonalDic) { + if (this.bPersonalDic) { yield* this.oPersonalDic.select(sPattern); } } } if (typeof(exports) !== 'undefined') { exports.SpellChecker = SpellChecker; } Index: graphspell/spellchecker.py ================================================================== --- graphspell/spellchecker.py +++ graphspell/spellchecker.py @@ -30,10 +30,13 @@ sfMainDic = dDefaultDictionaries.get(sLangCode, "") self.oMainDic = self._loadDictionary(sfMainDic, True) self.oExtendedDic = self._loadDictionary(sfExtendedDic) self.oCommunityDic = self._loadDictionary(sfCommunityDic) self.oPersonalDic = self._loadDictionary(sfPersonalDic) + self.bExtendedDic = bool(self.oExtendedDic) + self.bCommunityDic = bool(self.oCommunityDic) + self.bPersonalDic = bool(self.oPersonalDic) self.oTokenizer = None def _loadDictionary (self, source, bNecessary=False): "returns an IBDAWG object" if not source: @@ -61,21 +64,46 @@ return bool(self.oMainDic) def setExtendedDictionary (self, source): "returns True if the dictionary is loaded" self.oExtendedDic = self._loadDictionary(source) - return bool(self.oExtendedDic) + self.bExtendedDic = bool(self.oExtendedDic) + return self.bExtendedDic def setCommunityDictionary (self, source): "returns True if the dictionary is loaded" self.oCommunityDic = self._loadDictionary(source) - return bool(self.oPersonalDic) + self.bCommunityDic = bool(self.oCommunityDic) + return self.bCommunityDic def setPersonalDictionary (self, source): "returns True if the dictionary is loaded" self.oPersonalDic = self._loadDictionary(source) - return bool(self.oPersonalDic) + self.bPersonalDic = bool(self.oPersonalDic) + return self.bPersonalDic + + def activateExtendedDictionary (self): + if self.oExtendedDic: + self.bExtendedDic = True + + def activateCommunityDictionary (self): + if self.oCommunityDic: + self.bCommunityDic = True + + def activatePersonalDictionary (self): + if self.oPersonalDic: + self.bPersonalDic = True + + def deactivateExtendedDictionary (self): + self.bExtendedDic = False + + def deactivateCommunityDictionary (self): + self.bCommunityDic = False + + def deactivatePersonalDictionary (self): + self.bPersonalDic = False + # parse text functions def parseParagraph (self, sText, bSpellSugg=False): if not self.oTokenizer: @@ -110,82 +138,82 @@ def isValidToken (self, sToken): "checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)" if self.oMainDic.isValidToken(sToken): return True - if self.oExtendedDic and self.oExtendedDic.isValidToken(sToken): + if self.bExtendedDic and self.oExtendedDic.isValidToken(sToken): return True - if self.oCommunityDic and self.oCommunityDic.isValidToken(sToken): + if self.bCommunityDic and self.oCommunityDic.isValidToken(sToken): return True - if self.oPersonalDic and self.oPersonalDic.isValidToken(sToken): + if self.bPersonalDic and self.oPersonalDic.isValidToken(sToken): return True return False def isValid (self, sWord): "checks if sWord is valid (different casing tested if the first letter is a capital)" if self.oMainDic.isValid(sWord): return True - if self.oExtendedDic and self.oExtendedDic.isValid(sWord): + if self.bExtendedDic and self.oExtendedDic.isValid(sWord): return True - if self.oCommunityDic and self.oCommunityDic.isValid(sToken): + if self.bCommunityDic and self.oCommunityDic.isValid(sToken): return True - if self.oPersonalDic and self.oPersonalDic.isValid(sWord): + if self.bPersonalDic and self.oPersonalDic.isValid(sWord): return True return False def lookup (self, sWord): "checks if sWord is in dictionary as is (strict verification)" if self.oMainDic.lookup(sWord): return True - if self.oExtendedDic and self.oExtendedDic.lookup(sWord): + if self.bExtendedDic and self.oExtendedDic.lookup(sWord): return True - if self.oCommunityDic and self.oCommunityDic.lookup(sToken): + if self.bCommunityDic and self.oCommunityDic.lookup(sToken): return True - if self.oPersonalDic and self.oPersonalDic.lookup(sWord): + if self.bPersonalDic and self.oPersonalDic.lookup(sWord): return True return False def getMorph (self, sWord): "retrieves morphologies list, different casing allowed" lResult = self.oMainDic.getMorph(sWord) - if self.oExtendedDic: + if self.bExtendedDic: lResult.extend(self.oExtendedDic.getMorph(sWord)) - if self.oCommunityDic: + if self.bCommunityDic: lResult.extend(self.oCommunityDic.getMorph(sWord)) - if self.oPersonalDic: + if self.bPersonalDic: lResult.extend(self.oPersonalDic.getMorph(sWord)) return lResult def getLemma (self, sWord): return set([ s[1:s.find(" ")] for s in self.getMorph(sWord) ]) def suggest (self, sWord, nSuggLimit=10): "generator: returns 1, 2 or 3 lists of suggestions" yield self.oMainDic.suggest(sWord, nSuggLimit) - if self.oExtendedDic: + if self.bExtendedDic: yield self.oExtendedDic.suggest(sWord, nSuggLimit) - if self.oCommunityDic: + if self.bCommunityDic: yield self.oCommunityDic.suggest(sWord, nSuggLimit) - if self.oPersonalDic: + if self.bPersonalDic: yield self.oPersonalDic.suggest(sWord, nSuggLimit) def select (self, sPattern=""): "generator: returns all entries which morphology fits " yield from self.oMainDic.select(sPattern) - if self.oExtendedDic: + if self.bExtendedDic: yield from self.oExtendedDic.select(sPattern) - if self.oCommunityDic: + if self.bCommunityDic: yield from self.oCommunityDic.select(sPattern) - if self.oPersonalDic: + if self.bPersonalDic: yield from self.oPersonalDic.select(sPattern) def drawPath (self, sWord): self.oMainDic.drawPath(sWord) - if self.oExtendedDic: + if self.bExtendedDic: print("-----") self.oExtendedDic.drawPath(sWord) - if self.oCommunityDic: + if self.bCommunityDic: print("-----") self.oCommunityDic.drawPath(sWord) - if self.oPersonalDic: + if self.bPersonalDic: print("-----") self.oPersonalDic.drawPath(sWord)