Comment utiliser Flyspell pour corriger efficacement le mot précédent?

À partir du moment où j'ai commencé à utiliser Flyspell, c'était toujours pénible à utiliser. Je vérifie rarement le tampon entier pour les mots mal orthographiés, généralement je tape et une fois que je vois le mot souligné, je veux le corriger instantanément et continuer à taper. C'est simplement parce que j'ai peur d'oublier de corriger le mot plus tard et parce que lorsque je commence la vérification complète du tampon, iSpell donne trop de faux positifs. Donc, presque toujours, je corrige les mots dès que possible pendant que je tape.

Voici les fonctions intégrées que je connais et les raisons pour lesquelles elles ne sont pas efficaces (pour moi):

• flyspell-correct-word- Ceci est lié au clic de souris. Oubliez ça, je ne vais pas utiliser la souris.

• flyspell-correct-word-before-point- Je l'ai utilisé pendant un certain temps. Il a deux inconvénients:

  1. Par défaut, il affiche le menu GUI qui est difficile à utiliser sans souris et c'est vraiment encombrant lorsque vous avez une liste de corrections avec plus de 10 éléments.

  2. Cela ne fonctionne pas pour le mot bien avant le point. Je tape rapidement et lorsque je repère un mot mal orthographié, j'ai généralement un ou deux mots entre le mot mal orthographié et le point. Je dois déplacer le point, le mot correct, revenir en arrière. Oh.

• flyspell-auto-correct-word - Voir le point 2 ↑ plus cela ne fonctionne pas bien lorsque vous avez une longue liste de réalisations (à cause du cyclisme).

Q: Comment puis-je utiliser Flyspell efficacement, avec le clavier, pouvoir choisir parmi la liste des achèvements sans cycle, et avec la possibilité de corriger des mots encore plus ou moins éloignés?

Les réponses acceptables incluent des packages qui aident à naviguer vers le mot mal orthographié précédent, à le corriger et à revenir ou quelque chose comme ça, ainsi que de petits extraits, peut-être à partir de votre propre fichier de configuration, car je pense que d'autres personnes ont trouvé leurs moyens d'interagir efficacement avec Flyspell.

L'intégration flyspell-auto-correct-previous-wordfonctionne comme un charme pour moi. Je l'ai lié F12et je n'ai pas regardé en arrière. Il a toujours des mots corrects pour moi, peu importe le nombre de mots en arrière.

Dans la documentation de la fonction:

flyspell-auto-correct-previous-word is an interactive compiled Lisp
function in `flyspell.el'.

(flyspell-auto-correct-previous-word POSITION)

For more information check the manuals.

Auto correct the first misspelled word that occurs before point.
But don't look beyond what's visible on the screen.

De plus, si la première correction automatique ne vous a pas donné le bon mot, continuez à appuyer sur votre touche liée ( F12dans mon cas) pour parcourir toutes les options.

[Ma configuration de vérification orthographique]

Je suis sûr que d'autres personnes proposeront des solutions différentes qui seront utiles aux futurs lecteurs. Cependant, voici comment je gère actuellement cela.

Je pense que flyspell-correct-word-before-pointc'est un bon point de départ, car il peut au moins être invoqué en appuyant sur une touche et il affiche le menu des corrections possibles. Pour corriger le menu, j'ai écrit le package Ace Popup Menu qui utilise Avy comme backend. Cela remplace le menu contextuel GUI qui flyspell-correct-word-before-pointutilise (la fonction est appelée x-popup-menu) par un menu contextuel textuel qui présente des éléments de menu étiquetés: un ou deux frappes et vous avez terminé.

Pour résoudre le deuxième problème (incapacité à corriger les mots «à distance»), j'ai écrit cet assistant:

(defun flyspell-correct-previous (&optional words)
  "Correct word before point, reach distant words.

WORDS words at maximum are traversed backward until misspelled
word is found.  If it's not found, give up.  If argument WORDS is
not specified, traverse 12 words by default.

Return T if misspelled word is found and NIL otherwise.  Never
move point."
  (interactive "P")
  (let* ((Δ (- (point-max) (point)))
         (counter (string-to-number (or words "12")))
         (result
          (catch 'result
            (while (>= counter 0)
              (when (cl-some #'flyspell-overlay-p
                             (overlays-at (point)))
                (flyspell-correct-word-before-point)
                (throw 'result t))
              (backward-word 1)
              (setq counter (1- counter))
              nil))))
    (goto-char (- (point-max) Δ))
    result))

Cela semble fonctionner.

Avec helm-flyspell, vous pouvez choisir efficacement dans la liste des corrections. J'utilise le code suivant pour passer aux erreurs et les corriger avec, il enregistre la position du point au mark-ringafin que vous puissiez revenir à la position où vous avez commencé ou corrigé les mots précédemment:

(defun flyspell-goto-previous-error (arg)
  "Go to arg previous spelling error."
  (interactive "p")
  (while (not (= 0 arg))
    (let ((pos (point))
          (min (point-min)))
      (if (and (eq (current-buffer) flyspell-old-buffer-error)
               (eq pos flyspell-old-pos-error))
          (progn
            (if (= flyspell-old-pos-error min)
                ;; goto beginning of buffer
                (progn
                  (message "Restarting from end of buffer")
                  (goto-char (point-max)))
              (backward-word 1))
            (setq pos (point))))
      ;; seek the next error
      (while (and (> pos min)
                  (let ((ovs (overlays-at pos))
                        (r '()))
                    (while (and (not r) (consp ovs))
                      (if (flyspell-overlay-p (car ovs))
                          (setq r t)
                        (setq ovs (cdr ovs))))
                    (not r)))
        (backward-word 1)
        (setq pos (point)))
      ;; save the current location for next invocation
      (setq arg (1- arg))
      (setq flyspell-old-pos-error pos)
      (setq flyspell-old-buffer-error (current-buffer))
      (goto-char pos)
      (if (= pos min)
          (progn
            (message "No more miss-spelled word!")
            (setq arg 0))))))


(defun check-previous-spelling-error ()
  "Jump to previous spelling error and correct it"
  (interactive)
  (push-mark-no-activate)
  (flyspell-goto-previous-error 1)
  (call-interactively 'helm-flyspell-correct))

(defun check-next-spelling-error ()
  "Jump to next spelling error and correct it"
  (interactive)
  (push-mark-no-activate)
  (flyspell-goto-next-error)
  (call-interactively 'helm-flyspell-correct))

(defun push-mark-no-activate ()
  "Pushes `point' to `mark-ring' and does not activate the region
 Equivalent to \\[set-mark-command] when \\[transient-mark-mode] is disabled"
  (interactive)
  (push-mark (point) t nil)
  (message "Pushed mark to ring"))