Commits

kiilerix  committed df71049

spelling: fix some typos and frenchisms and sloppiness

  • Participants
  • Parent commits 300e00d

Comments (0)

Files changed (25)

File bin/hgview.bat

 import os.path as pos
 
 if getattr(sys, 'frozen', None) == "windows_exe":
-    # Standalone version of hgview built with py2exe use they how version
-    # of mercurial. Using configuration from the global Mercurial.ini will be
+    # Standalone version of hgview built with py2exe use its own version
+    # of Mercurial. Using configuration from the global Mercurial.ini will be
     # ill-advised as the installed version of Mercurial itself may be
     # different than the one we ship.
     #
-    # this will lay aside Mercurial.ini
+    # this will be found next to Mercurial.ini
     path = pos.join(os.path.expanduser('~'), 'hgview.ini')
     os.environ['HGRCPATH'] = path
 

File bin/hgview_py2exe.py

 import sys, os
 import os.path as pos
 
-# Standalone version of hgview built with py2exe use they how version
-# of mercurial. Using configuration from the global Mercurial.ini will be
+# Standalone version of hgview built with py2exe use its own version
+# of Mercurial. Using configuration from the global Mercurial.ini will be
 # ill-advised as the installed version of Mercurial itself may be
 # different than the one we ship.
 #
-# this will lay aside Mercurial.ini
+# this will be found next to Mercurial.ini
 path = pos.join(os.path.expanduser('~'), 'hgview.ini')
 os.environ['HGRCPATH'] = path
 
 
 # We could not import the module that defines the original class because
 # of sys._Messagebox missing error (see py2exe.boot_common.py). So, we
-# intropect to get access to the original class.
+# introspect to get access to the original class.
 LOGPATH = pos.join(pos.expanduser('~'), 'hgview.log') 
 class Stderr(sys.stderr.__class__):
     def write(self, *args, **kwargs):

File hgext/hgview.py

 # they are required.
 
 def start_hgview(ui, repo, *pats, **opts):
-    # WARNING, this docstring is superseeded programatically 
+    # WARNING, this docstring is superseeded programmatically 
     """
 start hgview log viewer
 =======================
     If a filename is given, launch the filelog diff viewer for this file, 
     and with the '-n' option, launch the filelog navigator for the file.
 
-    With the '-r' option, launch the manifest viexer for the given revision.
+    With the '-r' option, launch the manifest viewer for the given revision.
 
     """
     ### 2.5 compat

File hgviewlib/application.py

     """Base viewer class interface."""
     def __init__(self, *args, **kwargs):
         raise NotImplementedError(
-            'This feature has not yet been implemented. Comming soon ...')
+            'This feature has not yet been implemented. Coming soon ...')
 
 class FileViewer(Viewer):
     """Single file revision graph viewer."""
         super(ManifestViewer, self).__init__(**kwargs)
 
 class ApplicationError(ValueError):
-    """Exception that may occures while lunching the application"""
+    """Exception that may occur while launching the application"""
 
 class HgViewApplication(object):
-    # class that must be instancied
+    # class that must be instantiated
     FileViewer = FileViewer
     FileDiffViewer = FileDiffViewer
     HgRepoViewer = HgRepoViewer
 
 def main():
     """
-    Main application acces point.
+    Main application entry point.
     """
 
     usage = '''%prog [options] [filename]

File hgviewlib/config.py

     @cached
     def getDisplayDiffStats(self, default="yes"):
         """
-        displaydiffstats: flag controllong the appearance of the
+        displaydiffstats: flag controlling the appearance of the
                     'Diff' column in a revision's file list
         """
         val = str(self._fromconfig('displaydiffstats', default))
     @cached
     def getExportTemplate(self):
         """
-        exporttemplate: template used to serialise changeset metadata
+        exporttemplate: template used to serialize changeset metadata
                         while exporting into the window manager clipboard.
                         (default to `ui.logtemplate`)
         """
                self.ui.config('ui', 'logtemplate')
 
 _HgConfig = HgConfig
-# HgConfig is instanciated only once (singleton)
+# HgConfig is instantiated only once (singleton)
 #
 # this 'factory' is used to manage this (not using heavy guns of
 # metaclass or so)
 _hgconfig = None
 def HgConfig(ui):
-    """Factory to instanciate HgConfig class as a singleton
+    """Factory to instantiate HgConfig class as a singleton
     """
     # pylint: disable=E0102
     global _hgconfig

File hgviewlib/curses/application.py

     # pylint: disable=C0103
     pygments = None
     # pylint: enable=C0103
-# _________________________________________________________________ Applicaiton
+# _________________________________________________________________ Application
 
 class HgViewUrwidApplication(HgViewApplication):
     """
             if optimize_inotify:
                 import ctypes.util
                 orig = ctypes.util.find_library
-                ctypes.util.find_library = lambda lib: None # durty optim
+                ctypes.util.find_library = lambda lib: None # dirty optimization
             inotify(self.mainloop)
             if optimize_inotify:
                 ctypes.util.find_library = orig
 # ________________________________________________________________ patch screen
 def patch_screen(screen_cls):
     """
-    Return a patched screen class that allows parent token inheritence in
+    Return a patched screen class that allows parent token inheritance in
     the palette
     """
     class Palette(dict):
-        """Special dictionary that take into account parent token inheritence.
+        """Special dictionary that take into account parent token inheritance.
         """
         def __contains__(self, key):
             if super(Palette, self).__contains__(key):
                 return True
             if (not isinstance(key, _TokenType)) or (key.parent is None):
                 return False
-            if key.parent in self: # fonction is now recursive
+            if key.parent in self: # function is now recursive
                 self[key] = self[key.parent] # cache + __getitem__ ok
                 return True
             return False
         has_key = __contains__
 
     class PatchedScreen(screen_cls, object):
-        """hack Screen to allow parent token inheritence in the palette"""
+        """hack Screen to allow parent token inheritance in the palette"""
         # Use a special container for storing style definition. This container
-        # take into accoutn parent token inheritence
+        # take into account parent token inheritance
         # raw_display.Screen store the palette definition in the container
         # ``_pal_escape``, web_display and curses display in ``palette`` and
         # ``attrconv``
         '''
         def __init__(self, callback, redraw, redraw_levelno=logging.CRITICAL):
             """
-            :param callback: A funtion called to display a message as
+            :param callback: A function called to display a message as
                 ``callback(style, levelname, message)`` where:
 
                 * ``levelname`` is the name of the message level
 
                 Mostly, it is the ``set`` method of a ``Footer`` instance.
 
-            :param redraw: a function that performe the screen redrawing
+            :param redraw: a function that performs the screen redrawing
 
             """
             self.callback = callback

File hgviewlib/curses/canvas.py

 # this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Module that contains special canva features.
+Module that contains special canvas features.
 """
 # pylint: disable=W,C,I,R
 
 # hack marks: "#+": added, "#=": modified
 def apply_text_layout(text, attr, ls, maxcol, numbering=False): #=
     """
-    Hack for urwid.canvas.apply_text_layout that able to diwplay line numbers
+    Hack for urwid.canvas.apply_text_layout that able to display line numbers
     """
     if numbering: #+
         lnb = len(str(text.count('\n') + 1)) + 1 #+

File hgviewlib/curses/exceptions.py

     """Base class for all hgview curses exception """
 
 class CommandError(ValueError, HgviewCursesException):
-    """Error that occures while calling a command"""
+    """Error that occurs while calling a command"""
 
 class UnknownCommand(StopIteration, HgviewCursesException):
-    """Error that occures when not callback found"""
+    """Error that occurs when callback not found"""
 
 class RegisterCommandError(KeyError, HgviewCursesException):
-    """Error that occures when a conflict occures while registering a comand"""
+    """Error that occurs when a conflict occurs while registering a command"""

File hgviewlib/curses/graphlog.py

 
     def data(self, pos):
         """Return a widget and the position passed."""
-        # cache may be very hudge on very big repo
+        # cache may be very huge on very big repo
         # (cpython for instance: >1.5GB)
         if pos in self._data_cache: # speed up rendering
             return self._data_cache[pos], pos
                     continue
                 txts.append((field, txt))
                 txts.append(('default', ' '))
-            txts.pop() # remove pendding space
+            txts.pop() # remove pending space
             txts.append('\n')
-        txts.pop() # remove pendding newline
+        txts.pop() # remove pending newline
         # prepare other columns
         txter = lambda col, sz: Text(
                  (col, _COLUMNMAP[col](self.walker, ctx, gnode)[:sz]),
         important_styles = set(['ID', 'GraphLog.node'])
         if ctx.obsolete():
             spec_style.update(dict.fromkeys(all_styles, 'obsolete'))
-        # normal style: use special styles for woking directory and tip
+        # normal style: use special styles for working directory and tip
         style = None
         if gnode.rev is None:
             style = 'modified' # pending changes
             style = 'current'
         if style is not None:
             spec_style.update(dict.fromkeys(important_styles, style))
-        # focused style: use special stles for working directory and tip
+        # focused style: use special styles for working directory and tip
         foc_style.update(dict.fromkeys(all_styles, style or 'focus'))
         foc_style.update(dict.fromkeys(important_styles, 'focus.alternate'))
         # wrap widget with style modified
 
     :param state: Somewhere to keep the needed state in (init to [0, 0])
     :param char: character to use as node's symbol.
-    :pram height: minimal line number to use for this node
+    :param height: minimal line number to use for this node
     :param coldata: (idx, edges, ncols, coldiff)
-        * idx: column index for the curent changeset
+        * idx: column index for the current changeset
         * edges: a list of (col, next_col) indicating the edges between
           the current node and its parents.
         * ncols: number of columns (ongoing edges) in the current revision.
     """
     idx, edges, ncols, coldiff = coldata
     # graphlog is broken with multiple parent. But we have ignore that to allow
-    # some support of obsolet relation display
+    # some support of obsolete relation display
     # assert -2 < coldiff < 2
     assert height > 0
     if coldiff == -1:
     # print lines
     indentation_level = max(ncols, ncols + coldiff)
     for line in lines:
-        # justify to GRAPH_MIN_WIDTH for conveniance
+        # justify to GRAPH_MIN_WIDTH for convenience
         if len(line) < GRAPH_MIN_WIDTH:
             line.append(' ' * (GRAPH_MIN_WIDTH - len(line)))
         yield [('GraphLog', item) if isinstance(item, basestring) else item for item in line]

File hgviewlib/curses/mainframe.py

 
 def quitall():
     """
-    usage: quall
+    usage: quitall
 
     Quit the program
     """
         Show the help massage of the ``command``.
 
         :command: a command name for which to display the help.
-                  If omited, the overall program help is displayed.
+                  If omitted, the overall program help is displayed.
         """
         doc = None
         if command:
     def complete(self):
         """
         Lookup for text in the edit area (until the cursor) and complete with
-        available command names (one per call). Calling mutiple times
+        available command names (one per call). Calling multiple times
         consequently will loop over all candidates.
         """
         if self.previous_keypress != 'tab': # hard coded :/
 
     def history(self, next=True):
         """
-        Remind the commands history to the edit area. Calling mutiple times
+        Recall command from history to the edit area. Calling multiple times
         consequently will loop over all history entries.
 
         """
-        # key are hard coded :/
+        # keys are hard coded :/
         if self.previous_keypress not in ('up', 'down', 'ctrl p', 'ctrl n'):
             self._history[0] = self.get_edit_text()
             self._history.reset_position()

File hgviewlib/curses/manifest.py

         """Return the current context"""
         return self._ctx
     def set_ctx(self, ctx, reset_focus=True):
-        """set the curreont context (obsolete the content)"""
+        """set the current context (obsolete the content)"""
         self._cached_flags.clear()
         self._ctx = ctx
         self._files = tuple(self._ctx.files())
         if flag is None:
             flag = self._cached_flags.setdefault(filename,
                     self._walker.graph.fileflag(filename, self._ctx.rev()))
-        if not isinstance(flag, str): # I don't know why it could occures :P
+        if not isinstance(flag, str): # I don't know why it could occur :P
             flag = '?'
         return  AttrWrap(SelectableText(filename, align='right', wrap='clip'),
                          flag, 'focus')

File hgviewlib/curses/utils.py

     You can fix callback arguments when connecting and/or emmitting a command.
 
     Emit method accept a command line string. This command line can only be a
-    command namei if all arguments for all callbacks have been fixed (or if they
-    are optionals). Otherwise the command options can be automaticly parsed
+    command name if all arguments for all callbacks have been fixed (or if they
+    are optionals). Otherwise the command options can be automatically parsed
     by giving `CommandArg`s to register.
 
     """
         return help, args, calls
 
     def connect(self, name, callback, args=None, kwargs=None):
-        """Disconnect the ``callback`` assiciated to the givent ``args`` and
+        """Disconnect the ``callback`` associated to the given ``args`` and
         ``kwargs`` from the command ``name``.
 
         See documentation of ``emit_command`` for details about ``args`` and
         self._calls[name].append((callback, args, kwargs))
 
     def disconnect(self, name, callback, args=None, kwargs=None):
-        """Disconnect the ``callback`` assiciated to the givent ``args`` and
+        """Disconnect the ``callback`` associated to the given ``args`` and
         ``kwargs`` from the command ``name``.
 
         >>> from hgviewlib.curses import utils
             raise RegisterCommandError('Callbacks not connected.')
 
     def emit(self, cmdline, args=None, kwargs=None):
-        """Call all callbacks connected to the command previously registred.
+        """Call all callbacks connected to the command previously registered.
 
         Callbacks are processed as following::
 
 
 
 class HgCommandMap(object):
-    """Map keys to more expliite action names."""
+    """Map keys to more explicit action names."""
     _command_defaults = (
 
         ('f1', '@help'),
         self._map = dict(self._command_defaults)
     def __getitem__(self, key):
         """a.__getitem__(key) <=> a[key]
-        return an explicite name associated to the key or None if not found.
+        return an explicit name associated to the key or None if not found.
         """
         return self._map.get(key)
     def items(self):

File hgviewlib/curses/widgets.py

 
 
 class SelectableText(Text):
-    """A seletable Text widget"""
+    """A selectable Text widget"""
     _selectable = True
     keypress = lambda self, size, key: key
 
     |  Text with title |
     +------------------+
 
-    Use the ``title`` property to chage the footer text.
+    Use the ``title`` property to change the footer text.
 
     """
     def __init__(self, body):
 class SourceText(SelectableText):
     """A widget that display source code content.
 
-    It cans number lines and highlight content using pygments.
+    It can number lines and highlight content using pygments.
     """
 
     signals = ['highlight']
         self._lexer = lexer
         if lexer == None: # No lexer found => finish
             return
-        # reduce "lag" while rendering the text as pyments may take a while to
-        # highligth the text. So we colorize only the first part of the text
+        # reduce "lag" while rendering the text as pygments may take a while to
+        # highlight the text. So we colorize only the first part of the text
         # and delay coloring the full text. The 3000st chars seems good on my
         # laptop :)
         signals.delay_emit_signal(self, 'highlight', 0.05, self.text)

File hgviewlib/hggraph.py

 # this program.  If not, see <http://www.gnu.org/licenses/>.
 """helper functions and classes to ease hg revision graph building
 
-Based on graphlog's algorithm, with insipration stolen to TortoiseHg
+Based on graphlog's algorithm, with inspiration stolen to TortoiseHg
 revision grapher.
 """
 
     return False
 
 def _graph_iterator(repo, start_rev, stop_rev, reorder=False):
-    """Iter thought revisions from start_rev to stop_rev (included)
+    """Iter through revisions from start_rev to stop_rev (included)
     Handle Working directory as None.
     """
     # check parameters
             if not repo.mq.isapplied(patchname):
                 yield (patchname, 0, 0, [(0, 0 ,0, False)], [])
 
-    # No uncommited change
+    # No uncommitted change
     if start_rev is None and repo.status() == ([],)*7:
         start_rev = len(repo.changelog) -1
     assert start_rev is None or start_rev >= stop_rev
 class Graph(object):
     """
     Graph object to ease hg repo navigation. The Graph object
-    instanciate a `revision_grapher` generator, and provide a `fill`
+    instantiate a `revision_grapher` generator, and provide a `fill`
     method to build the graph progressively.
     """
     #@timeit
             self.nodesdict[nrev] = gnode
             mcol.append(gnode.cols)
             if rev is not None and nrev <= rev:
-                rev = None # we reached rev, switching to nnode counter
+                rev = None # we reached rev, switching to nnodes counter
             if rev is None:
                 if nnodes is not None:
                     nnodes -= 1

File hgviewlib/hgpatches/__init__.py

     context.changectx.troubles = troubles
 
 try:
-    # meaning of obsstore attribute have been flipped betwen mercurial 2.3 and
+    # meaning of obsstore attribute have been flipped between mercurial 2.3 and
     # mercurial 2.4
     import mercurial.obsolete
     mercurial.obsolete.getrevs

File hgviewlib/hgpatches/mqsupport.py

 # this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-The main goal of this module is to fakse mercurial change context classes from
+The main goal of this module is to create fake mercurial change context classes from
 data information available in mq patch files.
 
-Only methods that are requiered by hgview had been implemented.
+Only methods that are required by hgview had been implemented.
 They may have special features to help hgview, So use it with care.
 
 The main differences are:
 * files within patches are always displayed as modified files
 * manifest only shows files modified by the mq patch.
 * data may be empty (date, description, status, tags, branch, etc.)
-* the parent of a patch may by the last appied on or previous patch or nullid
+* the parent of a patch may by the last applied on or previous patch or nullid
 * the child of a patch is the next patch
 * patches are hidden
 """
 class MqChangeCtx(MqCtx):
     """
     A Mercurial change context fake for unapplied mq patch.
-    Use with care as methodes may be missing or have special features.
+    Use with care as methods may be missing or have special features.
     """
 
     def __init__(self, repo, patch_name):
         self._files_cache = None
 
     def __repr__(self):
-        return '<MQchangectx (unapplied) %s>' % self.name
+        return '<MqChangeCtx (unapplied) %s>' % self.name
 
     @property
     def _header(self):
         self._files_cache = ()
 
     def __repr__(self):
-        return '<MQchangectx (missing file) %s>' % self.name
+        return '<MqChangeCtx (missing file) %s>' % self.name
 
 class MqFileCtx(context.filectx):
     """Mq Fake for file context"""
         return False #  XXX
 
     def __repr__(self):
-        return ('<mqfilectx (unapplied) %s@%s>' %
+        return ('<MqFileCtx (unapplied) %s@%s>' %
                 (self._path, self._changectx.name))
 
     def flags(self):

File hgviewlib/qt4/blockmatcher.py

     A simple widget to be 'linked' to the scrollbar of a diff text
     view.
 
-    It represents diff blocks with coloured rectangles, showing
+    It represents diff blocks with colored rectangles, showing
     currently viewed area by a semi-transparant rectangle sliding
     above them.
     """
 
 class BlockMatch(BlockList):
     """
-    A simpe widget to be linked to 2 file views (text areas),
+    A simple widget to be linked to 2 file views (text areas),
     displaying 2 versions of a same file (diff).
 
     It will show graphically matching diff blocks between the 2 text

File hgviewlib/qt4/hgdialogmixin.py

 # this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #
-# make sur the Qt rc files are converted into python modules, then load them
+# make sure the Qt rc files are converted into python modules, then load them
 # this must be done BEFORE other hgview qt4 modules are loaded.
 import os
 import os.path as osp
 
 class HgDialogMixin(object):
     """
-    Mixin for QDialogs defined from a .ui file, wich automates the
+    Mixin for QDialogs defined from a .ui file, which automates the
     setup of the UI from the ui file, and the loading of user
     preferences.
-    The main class must define a '_ui_file' class attribute.
+    The main class must define a '_uifile' class attribute.
     """
     def __init__(self):
         # self.repo must be defined in actual class before calling __init__
         self.disab_shortcuts = []
 
     def load_ui(self):
-        # we explicitely create a QShortcut so we can disable it
+        # we explicitly create a QShortcut so we can disable it
         # when a "helper context toolbar" is activated (which can be
         # closed hitting the Esc shortcut)
         self.esc_shortcut = QtGui.QShortcut(self)

File hgviewlib/qt4/hgfileview.py

 qsci = Qsci.QsciScintilla
 
 class Annotator(qsci):
-    # we use a QScintilla for the annotater cause it makes
-    # it much easier to keep the text area and the annotater sync
+    # we use a QScintilla for the annotator cause it makes
+    # it much easier to keep the text area and the annotator sync
     # (same font rendering etc). However, it have the drawback of making much
     # more difficult to implement things like QTextBrowser.anchorClicked, which
     # would have been nice to directly go to the annotated revision...
             ("diffmode", self.tr("Diff mode"), 'diffmode' ,
              self.tr('Enable/Disable Diff mode'), None, None),
             ("annmode", self.tr("Annotate mode"), None,
-             self.tr('Anable/Disable Annotatte mode'), None, None),
+             self.tr('Enable/Disable Annotate mode'), None, None),
             ("next", self.tr('Next hunk'), 'down', self.tr('Jump to the next hunk'),
              Qt.ALT + Qt.Key_Down, None),
             ("prev", self.tr('Prior hunk'), 'up', self.tr('Jump to the previous hunk'),

File hgviewlib/qt4/hgrepomodel.py

                 self.killTimer(self._fill_timer)
                 self._fill_timer = None
                 self.emit(SIGNAL('showMessage'), '', -1)
-            # we only fill the graph data strctures without telling
-            # views (until we atually did the full job), to keep
-            # maximal GUI reactivity
+            # we fill the graph data structures without telling
+            # views until we are done - this gives
+            # maximal GUI responsiveness
             elif not self.graph.build_nodes(nnodes=self.fill_step):
                 self.killTimer(self._fill_timer)
                 self._fill_timer = None

File hgviewlib/qt4/hgrepoview.py

         w.activateWindow()
 
     def auto_search(self, revexp):
-        # Do not automatically search for revision nimber.
+        # Do not automatically search for revision number.
         # The problem is that the auto search system will
         # query for lower revision number: users may type the revision
         # number by hand which induce that the first numeric char will be
-        # querined alone.
+        # queried alone.
         # But the first found revision is automatically selected, so to much
         # revision tree will be loaded.
         if revexp.isdigit():
             self._actions['prev'].setEnabled(True)
             self.show_message(
                 'Hit [Enter] because '
-                'revision number is not automaically queried '
-                'for optimmization purpose.')
+                'revision number is not automatically queried '
+                'for optimization purpose.')
             self._standby_revexp = revexp
             return
         self.search(revexp)
             if self.entry.status == 'failed':
                 self.show_message("Invalid revset expression.")
             else:
-                self.show_message("Quering, please wait (or edit to cancel).")
+                self.show_message("Querying, please wait (or edit to cancel).")
             return
         if self._standby_revexp is not None:
             self.search(self._standby_revexp, threaded=False)
             self.emit(SIGNAL('new_set'), None)
             self.emit(SIGNAL('goto_next_from'), (self.row_before,))
             return
-        self.show_message("Quering ... (edit the entry to cancel)")
+        self.show_message("Querying ... (edit the entry to cancel)")
         self._actions['next'].setEnabled(False)
         self._actions['prev'].setEnabled(False)
         self.entry.status = 'query'
             ActDef(name="back",
                    desc=self.tr("Previous visited"),
                    icon='back',
-                   tip=self.tr("Barward to the previous visited changeset"),
+                   tip=self.tr("Backward to the previous visited changeset"),
                    keys=[QtGui.QKeySequence(QtGui.QKeySequence.Back)],
                    cb=self.back),
             ActDef(name="forward",
         self._actions['unfilter'].setEnabled(rev is not None)
 
     def copy_cs_to_clipboard(self):
-        """ Copy changeset metada into the window manager clipboard."""
+        """ Copy changeset metadata into the window manager clipboard."""
         repo = self.model().repo
         ctx = repo[self.current_rev]
         u = ui.ui(repo.ui)
         self._rev_pos = -1
         self._in_history = False # flag set when we are "in" the
         # history. It is required cause we cannot known, in
-        # "revision_selected", if we are crating a new branch in the
+        # "revision_selected", if we are creating a new branch in the
         # history navigation or if we are navigating the history
 
     def setModel(self, model):

File hgviewlib/qt4/hgrepoviewer.py

         """Starts the process of filling the HgModel"""
         branch = str(self.branch_comboBox.currentText())
         startrev = kw.get('rev', None)
-        # XXX workaround: self.sender() may provoque a core dump if
+        # XXX workaround: self.sender() may provoke a core dump if
         # this method is called directly (not via a connected signal);
-        # the 'sender' keyword is a way to discrimimne that the method
+        # the 'sender' keyword is a way to detect that the method
         # has been called directly (thus caller MUST set this kw arg)
         sender = kw.get('sender') or self.sender()
         follow = kw.get('follow', False)

File hgviewlib/qt4/quickbar.py

         connect(self._actions['cancel'], SIGNAL('triggered()'), self.cancel)
 
     def find(self, *args):
-        '''Scan the repository metadata and search for occurence of the
-        text in tre entry.
+        '''Scan the repository metadata and search for occurrences of the
+        text in the entry.
         :note: do not scan if no text was provided'''
         text = unicode(self.entry.text())
         if not text: # do not strip() as user may want to find space sequences

File hgviewlib/util.py

 ESC_UCAR_TABLE = unicode(ESC_CAR_TABLE, 'latin1')
 
 def xml_escape(data):
-    """escapes XML forbidden characters in attributes and PCDATA"""
+    """escapes XML forbidden characters in attributes and CDATA"""
     if isinstance(data, unicode):
         data = data.translate(ESC_UCAR_TABLE)
     else:
 
     def has_fullhgext(self):
         """XXX ugly hack to include hgext in standalone hgview.exe"""
-        return py2exe is not None # hugly hack to include every hgext modules
+        return py2exe is not None # ugly hack to include every hgext modules
 
     # 'sub_commands': a list of commands this command might have to run to
     # get its work done.  See cmd.py for more info.