[elpa] externals/jinx 524711ef85 7/8: Improve readme

[ELPA Syncer]

branch: externals/jinx
commit 524711ef85471eacd273a2143152ea71c4a76501
Author: Daniel Mendler <mail@daniel-mendler.de>
Commit: Daniel Mendler <mail@daniel-mendler.de>

    Improve readme
---
 README.org | 121 +++++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 77 insertions(+), 44 deletions(-)

diff --git a/README.org b/README.org
index 7baa18a73d..6d926b65ea 100644
--- a/README.org
+++ b/README.org
@@ -12,37 +12,48 @@
 #+html: <a href="https://melpa.org/#/jinx";><img alt="MELPA" 
src="https://melpa.org/packages/jinx-badge.svg"/></a>
 #+html: <a href="https://stable.melpa.org/#/jinx";><img alt="MELPA Stable" 
src="https://stable.melpa.org/packages/jinx-badge.svg"/></a>
 
-Jinx is a just-in-time spell-checker for Emacs. Jinx highlights misspelled 
words in the text of the visible portion of the buffer. Each misspelling can 
then be corrected from a list of dictionary words presented as the usual 
completion candidates in a list.
-
-Installing Jinx is straight-forward and configuring takes not much 
intervention. Jinx can safely co-exist with Emacs's built-in spell-checker.
-
-Jinx's high performance and low resource usage comes from directly calling the 
widely-used API of the Enchant library (see 
[[https://abiword.github.io/enchant/][libenchant]]).  Jinx package 
automatically compiles =jinx-mod.c= and loads the dynamic module at startup. 
-
-Jinx highlights misspellings lazily, recognizes window boundaries and text 
folding, if any. By binding directly to the native libenchant API, Jinx avoids 
the slower backend process communication with Aspell. Thanks to libenchant API, 
this method is widely used by text editors and supports 
[[https://nuspell.github.io/][Nuspell]], 
[[http://hunspell.github.io/][Hunspell]], [[http://aspell.net/][Aspell]] and a 
few lesser known
-backends.  
-
-Jinx supports spell-checking multiple languages in the same buffer. See the 
=jinx-languages= variable to customize for multiple languages.
-
-Jinx can flexibly ignore misspellings via faces (=jinx-exclude-faces= and 
=jinx-include-faces=), regular
-expressions (=jinx-exclude-regexps=), and programmable predicates. Jinx comes 
preconfigured for the most important Emacs major modes.
+Jinx is a fast just-in-time spell-checker for Emacs. Jinx highlights misspelled
+words in the text of the visible portion of the buffer. Each misspelling can
+then be corrected from a list of dictionary words presented as completion
+candidates in a list.
+
+Installing Jinx is straight-forward and configuring takes not much 
intervention.
+Jinx can safely co-exist with Emacs's built-in spell-checker.
+
+Jinx's high performance and low resource usage comes from directly calling the
+widely-used API of the Enchant library (see 
[[https://abiword.github.io/enchant/][libenchant]]). Jinx package
+automatically compiles =jinx-mod.c= and loads the dynamic module at startup.
+
+Jinx highlights misspellings lazily, recognizes window boundaries and text
+folding, if any. By binding directly to the native Enchant API, Jinx avoids
+the slower backend process communication with Aspell. Thanks to Enchant API,
+this method is widely used by other text editors and supports 
[[https://nuspell.github.io/][Nuspell]], 
[[http://hunspell.github.io/][Hunspell]],
+[[http://aspell.net/][Aspell]] and a few lesser known backends.
+
+Jinx supports spell-checking multiple languages in the same buffer. See the
+=jinx-languages= variable to customize for multiple languages. Jinx can 
flexibly
+ignore misspellings via faces (=jinx-exclude-faces= and =jinx-include-faces=),
+regular expressions (=jinx-exclude-regexps=), and programmable predicates. Jinx
+comes preconfigured for the most important Emacs major modes.
 
 #+html: <img 
src="https://github.com/minad/jinx/blob/screenshots/screenshot.png?raw=true";>
 
 * Installing Jinx
 
-Jinx can be installed from GNU ELPA and MELPA directly or with 
=package-install=. 
+Jinx can be installed from GNU ELPA and MELPA directly or with 
=package-install=.
 
-Jinx requires =libenchant=. Enchant library is a required dependency for Jinx 
to compile its module at install time. If =pkg-config= is available when 
installing Jinx, Jinx will use =pkg-config= to locate =libenchant=. 
+Jinx requires =libenchant=. Enchant library is a required dependency for Jinx 
to
+compile its module at install time. If =pkg-config= is available when 
installing
+Jinx, Jinx will use =pkg-config= to locate =libenchant=.
 
-On Debian or Ubuntu, install packages =libenchant-2-2=, =libenchant-2-dev= and 
=pkg-config=.
-
-On Fedora or RHEL, install the package =enchant2-devel=.
-
-On Mac or Darwin systems, install =enchant2= and =pkgconfig=.
+On Debian or Ubuntu, install packages =libenchant-2-2=, =libenchant-2-dev= and
+=pkg-config=. On Fedora or RHEL, install the package =enchant2-devel=. On Mac,
+install =enchant2= and =pkgconfig=.
 
 * Using Jinx
 
-Jinx has two modes: the command, =global-jinx-mode= activates globally; and 
the command, =jinx-mode=, for activiating for specific modes.  
+Jinx has two modes: the command, =global-jinx-mode= activates globally; and the
+command, =jinx-mode=, for activating for specific modes.
 
 #+begin_src emacs-lisp
   (add-hook 'emacs-startup-hook #'global-jinx-mode)
@@ -51,40 +62,62 @@ Jinx has two modes: the command, =global-jinx-mode= 
activates globally; and the
     (add-hook hook #'jinx-mode))
 #+end_src
 
-A sample configuration with the popular =use-package= macro is shown here:
+Jinx autoloads the commands =jinx-correct= and =jinx-languages=. Invoking
+=jinx-correct= corrects the misspellings. Binding =jinx-correct= to =M-$= 
chord takes
+over that chord from Emacs's default assignment to =ispell word=. Since Jinx is
+independent of the Emacs's Ispell package, =M-$= can be re-used. The 
=use-package=
+definition above shows that. The same reassignment using regular keymap is 
shown
+below:
 
 #+begin_src emacs-lisp
-(use-package jinx
-  :commands (jinx-correct jinx-languages)
-  :hook (emacs-startup . global-jinx-mode)
-  :bind ([remap ispell-word] . jinx-correct))
+  (keymap-global-set "<remap> <ispell-word>" #'jinx-correct)
 #+end_src
 
-Jinx autoloads the commands =jinx-correct= and =jinx-languages=. Invoking 
=jinx-correct= corrects the misspellings. Binding =jinx-correct= to =M-$= chord 
takes over that chord from Emacs's default assignment to =ispell word=. Since 
Jinx is independent of the Emacs's Ispell package, =M-$= can be re-used. The 
=use-package= definition above shows that. The same reassignment using regular 
keymap is shown below:
+- =M-$= triggers correction for the misspelled word next to point.
+- =C-u M-$= triggers correction for the entire buffer.
+
+A sample configuration with the popular =use-package= macro is shown here:
 
 #+begin_src emacs-lisp
-  (keymap-global-set "<remap> <ispell-word>" #'jinx-correct)
+  (use-package jinx
+    :hook (emacs-startup . global-jinx-mode)
+    :bind ([remap ispell-word] . jinx-correct))
 #+end_src
 
-=M-$= triggers correction for the misspelled word next to point. 
-
-=C-u M-$= triggers correction for the entire buffer. 
-
 * Enchant backends and personal dictionaries
 
-Enchant uses different backends for different languages (to be spell-checked). 
The backends are ordered as specified in the configuration file 
=~/.config/enchant/enchant.ordering=. For most languages, Enchant uses Hunspell 
by default. 
-
-Depending on the backend the personal dictionary will be taken from different 
locations, e.g., =~/.aspell.LANG.pws= or =~/.config/enchant/=. It is possible 
to symlink different personal dictionaries
-such that they are shared by different spell checkers. See the 
[[https://abiword.github.io/enchant/src/enchant.html][Enchant manual]] for 
details.
-
-* Alternate spell check programs
-
-- [[https://github.com/astoff/jit-spell][jit-spell]]: Jinx UI borrows ideas 
from Augusto Stoffel's jit-spell even if Jit-spell uses Ispell process 
communication instead Jinx's calling native API. Since jit-spell highlights 
misspellings in the entire buffer and does not confine to just the visible 
text, jit-spell has load and latency consequences especially in stealth locking 
and eager fontification. This overhead is similar to =consult-line= from my 
[[https://github.com/minad/consult][Co [...]
-
-- [[https://codeberg.org/ideasman42/emacs-spell-fu][spell-fu]]: The idea to 
highlight misspellings just in the visible text portion of the buffer came from 
Campbell Barton's spell-fu package. Spell-fu however incurrs high memory 
overhead on account of its dictionary in a hash table. For languages with 
compound words and inflected word forms, this memory overhead magnifies. By 
accessing the enchant API directly, Jinx avoids this overhead. Jinx also 
benefits from enchant's advanced spell-c [...]
+Enchant uses different backends for different languages (to be spell-checked).
+The backends are ordered as specified in the configuration file
+=~/.config/enchant/enchant.ordering=. For most languages, Enchant uses 
Hunspell by
+default.
+
+Depending on the backend the personal dictionary will be taken from different
+locations, e.g., =~/.aspell.LANG.pws= or =~/.config/enchant/=. It is possible 
to
+symlink different personal dictionaries such that they are shared by different
+spell checkers. See the 
[[https://abiword.github.io/enchant/src/enchant.html][Enchant manual]] for 
details.
+
+* Alternative spell-checking packages
+
+- [[https://github.com/astoff/jit-spell][jit-spell]]: Jinx UI borrows ideas 
from Augusto Stoffel's Jit-spell. Jit-spell
+  uses the less efficient Ispell process communication instead Jinx's calling
+  native API. Since Jit-spell highlights misspellings in the entire buffer and
+  does not confine to just the visible text, Jit-spell has load and latency
+  consequences especially in stealth locking and eager fontification.
+
+- [[https://codeberg.org/ideasman42/emacs-spell-fu][spell-fu]]: The idea to 
highlight misspellings just in the visible text portion
+  of the buffer came from Campbell Barton's spell-fu package. Spell-fu however
+  incurs high memory overhead on account of its dictionary in a hash table. For
+  languages with compound words and inflected word forms, this memory overhead
+  magnifies. By accessing the Enchant API directly, Jinx avoids this overhead.
+  Jinx also benefits from Enchant's advanced spell-checker algorithms
+  (affixation, compound words, etc.).
+
+- flyspell: Flyspell is Emacs's built-in package. Flyspell highlights
+  misspellings in realtime, while typing. Each word under the cursor is
+  spell-checked and underlined if mistyped. Jinx, on the other hand, is more
+  effective because it checks for misspellings in the entire visible text of 
the
+  buffer at once.
 
-- flyspell: Flyspell is Emacs's built-in package. Flyspelll highlights 
misspellings realt-time, while typing. Each word under the cursor is 
spell-checked and underlined if mistyped. Jinx, on the other hand, is a bit 
more efficient because it checks for misspellings in the entire visible text of 
the buffer at once.
-  
 * Contributions
 
 Since this package is part of [[https://elpa.gnu.org/packages/jinx.html][GNU 
ELPA]] contributions require a copyright assignment to the FSF.