eric: comparison src/eric7/QScintilla/SpellChecker.py

-:e440aaf179ce
+:64157aeb0312
 def __init__(self, editor, indicator, defaultLanguage=None, checkRegion=None):
 """
 Constructor
-@param editor reference to the editor object (QScintilla.Editor)
+@param editor reference to the editor object
+@type QScintilla.Editor
 @param indicator spell checking indicator
-@param defaultLanguage the language to be used as the default
+@type int
-(string). The string should be in language locale format
+@param defaultLanguage the language to be used as the default. The string
-(e.g. en_US, de).
+should be in language locale format (e.g. en_US, de).
+@type str
 @param checkRegion reference to a function to check for a valid
 region
+@type function
 """
 super().__init__(editor)
 self.editor = editor
 self.indicator = indicator
 @classmethod
 def getAvailableLanguages(cls):
 """
 Class method to get all available languages.
-@return list of available languages (list of strings)
+@return list of available languages
+@rtype list of str
 """
 with contextlib.suppress(NameError):
 return enchant.list_languages()
 return []
 @classmethod
 def isAvailable(cls):
 """
 Class method to check, if spellchecking is available.
-@return flag indicating availability (boolean)
+@return flag indicating availability
+@rtype bool
 """
 if Preferences.getEditor("SpellCheckingEnabled"):
 with contextlib.suppress(NameError, AttributeError):
 return len(enchant.list_languages()) > 0
 return False
 def getDefaultPath(cls, isException=False):
 """
 Class method to get the default path names of the user dictionaries.
 @param isException flag indicating to return the name of the default
-exception dictionary (boolean)
+exception dictionary
+@type bool
 @return file name of the default user dictionary or the default user
-exception dictionary (string)
+exception dictionary
+@rtype str
 """
 if isException:
 return os.path.join(Globals.getConfigDir(), "spelling", "pel.dic")
 else:
 return os.path.join(Globals.getConfigDir(), "spelling", "pwl.dic")
 def getUserDictionaryPath(cls, isException=False):
 """
 Class method to get the path name of a user dictionary file.
 @param isException flag indicating to return the name of the user
-exception dictionary (boolean)
+exception dictionary
+@type bool
 @return file name of the user dictionary or the user exception
-dictionary (string)
+dictionary
+@rtype str
 """
 if isException:
 dicFile = Preferences.getEditor("SpellCheckingPersonalExcludeList")
 if not dicFile:
 dicFile = SpellChecker.getDefaultPath(True)
 @classmethod
 def _getDict(cls, lang, pwl="", pel=""):
 """
 Protected class method to get a new dictionary.
-@param lang the language to be used as the default (string).
+@param lang the language to be used as the default. The string should
-The string should be in language locale format (e.g. en_US, de).
+be in language locale format (e.g. en_US, de).
-@param pwl name of the personal/project word list (string)
+@type str
-@param pel name of the personal/project exclude list (string)
+@param pwl name of the personal/project word list
-@return reference to the dictionary (enchant.Dict)
+@type str
+@param pel name of the personal/project exclude list
+@type str
+@return reference to the dictionary
+@rtype enchant.Dict
 """
 if not pwl:
 pwl = SpellChecker.getUserDictionaryPath()
 d = os.path.dirname(pwl)
 if not os.path.exists(d):
 @classmethod
 def setDefaultLanguage(cls, language):
 """
 Class method to set the default language.
-@param language the language to be used as the default (string).
+@param language the language to be used as the default. The string should
-The string should be in language locale format (e.g. en_US, de).
+be in language locale format (e.g. en_US, de).
+@type str
 """
 cls._spelling_lang = language
 cls._spelling_dict = cls._getDict(language)
 def setLanguage(self, language, pwl="", pel=""):
 """
 Public method to set the current language.
-@param language the language to be used as the default (string).
+@param language the language to be used as the default. The string should
-The string should be in language locale format (e.g. en_US, de).
+be in language locale format (e.g. en_US, de).
-@param pwl name of the personal/project word list (string)
+@type str
-@param pel name of the personal/project exclude list (string)
+@param pwl name of the personal/project word list
+@type str
+@param pel name of the personal/project exclude list
+@type str
 """
 self._spelling_lang = language
 self._spelling_dict = self._getDict(language, pwl=pwl, pel=pel)
 def getLanguage(self):
 """
 Public method to get the current language.
-@return current language in language locale format (string)
+@return current language in language locale format
+@rtype str
 """
 return self._spelling_lang
 def setMinimumWordSize(self, size):
 """
 Public method to set the minimum word size.
-@param size minimum word size (integer)
+@param size minimum word size
+@type int
 """
 if size > 0:
 self.minimumWordSize = size
 def __getNextWord(self, pos, endPosition):
 """
 Private method to get the next word in the text after the given
 position.
-@param pos position to start word extraction (integer)
+@param pos position to start word extraction
-@param endPosition position to stop word extraction (integer)
+@type int
-@return tuple of three values (the extracted word (string),
+@param endPosition position to stop word extraction
-start position (integer), end position (integer))
+@type int
+@return tuple of three values (the extracted word, start position, end position)
+@rtype tuple of (str, int, int)
 """
 if pos < 0 or pos >= endPosition:
 return "", -1, -1
 ch = self.editor.charAt(pos)
 def getContext(self, wordStart, wordEnd):
 """
 Public method to get the context of a faulty word.
-@param wordStart the starting position of the word (integer)
+@param wordStart the starting position of the word
-@param wordEnd the ending position of the word (integer)
+@type int
-@return tuple of the leading and trailing context (string, string)
+@param wordEnd the ending position of the word
+@type int
+@return tuple of the leading and trailing context
+@rtype tuple of (str, str)
 """
 sline, sindex = self.editor.lineIndexFromPosition(wordStart)
 eline, eindex = self.editor.lineIndexFromPosition(wordEnd)
 text = self.editor.text(sline)
 return (text[:sindex], text[eindex:])
 def getError(self):
 """
 Public method to get information about the last error found.
-@return tuple of last faulty word (string), starting position of the
+@return tuple of last faulty word, starting position of the
-faulty word (integer) and ending position of the faulty word
+faulty word and ending position of the faulty word
-(integer)
+@rtype tuple of (str, int, int)
 """
 return (self.word, self.wordStart, self.wordEnd)
 def initCheck(self, startPos, endPos):
 """
 Public method to initialize a spell check.
-@param startPos position to start at (integer)
+@param startPos position to start at
-@param endPos position to end at (integer)
+@type int
-@return flag indicating successful initialization (boolean)
+@param endPos position to end at
+@type int
+@return flag indicating successful initialization
+@rtype bool
 """
 if startPos == endPos:
 return False
 spell = self._spelling_dict
 def __checkDocumentPart(self, startPos, endPos):
 """
 Private method to check some part of the document.
-@param startPos position to start at (integer)
+@param startPos position to start at
-@param endPos position to end at (integer)
+@type int
+@param endPos position to end at
+@type int
 """
 if not self.initCheck(startPos, endPos):
 return
 while True:
 def checkWord(self, pos, atEnd=False):
 """
 Public method to check the word at position pos.
-@param pos position to check at (integer)
+@param pos position to check at
-@param atEnd flag indicating the position is at the end of the word
+@type int
-to check (boolean)
+@param atEnd flag indicating the position is at the end of the word to check
+@type bool
 """
 spell = self._spelling_dict
 if spell is None:
 return
 def checkLines(self, firstLine, lastLine):
 """
 Public method to check some lines of text.
-@param firstLine line number of first line to check (integer)
+@param firstLine line number of first line to check
-@param lastLine line number of last line to check (integer)
+@type int
+@param lastLine line number of last line to check
+@type int
 """
 startPos = self.editor.positionFromLineIndex(firstLine, 0)
 if lastLine >= self.editor.lines():
 lastLine = self.editor.lines() - 1
 def getSuggestions(self, word):
 """
 Public method to get suggestions for the given word.
-@param word word to get suggestions for (string)
+@param word word to get suggestions for
-@return list of suggestions (list of strings)
+@type str
+@return list of suggestions
+@rtype list of str
 """
 suggestions = []
 spell = self._spelling_dict
 if spell and len(word) >= self.minimumWordSize:
 with contextlib.suppress(enchant.errors.Error):
 def add(self, word=None):
 """
 Public method to add a word to the personal word list.
-@param word word to add (string)
+@param word word to add
+@type str
 """
 spell = self._spelling_dict
 if spell:
 if word is None:
 word = self.word
 def remove(self, word):
 """
 Public method to add a word to the personal exclude list.
-@param word word to add (string)
+@param word word to add
+@type str
 """
 spell = self._spelling_dict
 if spell:
 spell.remove(word)
 def ignoreAlways(self, word=None):
 """
 Public method to tell the checker, to always ignore the given word
 or the current word.
-@param word word to be ignored (string)
+@param word word to be ignored
+@type str
 """
 if word is None:
 word = self.word
 if word not in self.__ignoreWords:
 self.__ignoreWords.append(word)
 def replace(self, replacement):
 """
 Public method to tell the checker to replace the current word with
 the replacement string.
-@param replacement replacement string (string)
+@param replacement replacement string
+@type str
 """
 sline, sindex = self.editor.lineIndexFromPosition(self.wordStart)
 eline, eindex = self.editor.lineIndexFromPosition(self.wordEnd)
 self.editor.setSelection(sline, sindex, eline, eindex)
 self.editor.beginUndoAction()
 def replaceAlways(self, replacement):
 """
 Public method to tell the checker to always replace the current word
 with the replacement string.
-@param replacement replacement string (string)
+@param replacement replacement string
+@type str
 """
 self.__replaceWords[self.word] = replacement
 self.replace(replacement)
 ##################################################################
 def __iter__(self):
 """
 Special method to create an iterator.
 @return self
+@rtype SpellChecker
 """
 return self
 def __next__(self):
 """
 Special method to advance to the next error.
 @return self
+@rtype SpellChecker
 @exception StopIteration raised to indicate the end of the iteration
 """
 spell = self._spelling_dict
 if spell:
 while self.pos < self.endPos and self.pos >= 0:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/QScintilla/SpellChecker.py

src/eric7/QScintilla/SpellChecker.py