[DOCS] Fix problem with Edit in github link

The link is created with docs in it, even if the mkdocs.yml file
mentions doc as the documentation folder. I am not aware if there is
any other dependency in the name doc, I have renamed it to docs and
changed it also in the mkdocs.yml file. It seems docs is hardcoded in
the readthedocs theme :(
This commit is contained in:
Kostas Tsiligkiris 2022-02-20 11:44:08 +02:00 committed by Bozhidar Batsov
parent 3f5e83d0e9
commit 9ed0d772da
26 changed files with 1 additions and 1 deletions

28
docs/modules/clojure.md Normal file
View file

@ -0,0 +1,28 @@
# Prelude Clojure
!!! Note
This module builds on top of the shared [Lisp Base](lisp.md) module.
## Clojure Mode
This module bundles `clojure-mode`, a major mode for programming in Clojure,
and some sensible defaults for it.
## CIDER
This module also bundles [CIDER](https://docs.cider.mx), a popular interactive
programming environment for Clojure.
Intentionally, Prelude doesn't install by default popular CIDER plugins like
`clj-refactor`, `sayid`, etc, as those can be overwhelming to newcomers and
are easy to setup if you need them.
## CIDER Alternatives
Depending on your preferences you might want to use `inf-clojure` or `clojure-lsp`
alongside/instead of CIDER, but you'll have to set them up yourselves.
## Fun trivia
I'm the author of CIDER and `inf-clojure` and the primary maintainer of `clojure-mode`. I'm also a co-maintainer of `clj-refactor`. I guess I love Clojure! :-)

View file

@ -0,0 +1,33 @@
# Prelude Common Lisp
!!! Note
This module builds on top of the shared [Lisp Base](lisp.md) module.
## lisp-mode
Not much to say here, as `lisp-mode` is configured in the "Lisp Base" module.
## SLIME
This module bundles [SLIME](https://common-lisp.net/project/slime/), a popular interactive
programming environment for SLIME, and enables many of its essential features.
SLIME supports many Common Lisp implementations:
* CMU Common Lisp (CMUCL)
* Steel Bank Common Lisp (SBCL)
* Clozure CL (a.k.a. OpenMCL)
* LispWorks
* Allegro CL
* CLISP
* Scieneer CL
* ECL
* Corman CL
* ABCL
The default config assumes the usage of [Clozure CL](https://github.com/Clozure/ccl) on macOS and
of [SBCL](http://www.sbcl.org/) everywhere else. That's something you can easily
tweak via `slime-default-lisp`.
You can start SLIME with `M-x slime`.

28
docs/modules/company.md Normal file
View file

@ -0,0 +1,28 @@
# Prelude Company
!!! Note
This module is enabled by default.
[company](https://company-mode.github.io/) is a completion library.
This module simply provides some reasonable defaults for it and enables `company-mode`:
```
(setq company-idle-delay 0.5)
(setq company-show-numbers t)
(setq company-tooltip-limit 10)
(setq company-minimum-prefix-length 2)
(setq company-tooltip-align-annotations t)
;; invert the navigation direction if the the completion popup-isearch-match
;; is displayed on top (happens near the bottom of windows)
(setq company-tooltip-flip-when-above t)
(global-company-mode 1)
```
You can adjust the configuration further in your personal config.
`company-mode` has [many extensions](https://github.com/company-mode/company-mode/wiki/Third-Party-Packages)
for various programming languages.
Some of Prelude's modules will install and enable the relevant extensions when necessary.

23
docs/modules/dart.md Normal file
View file

@ -0,0 +1,23 @@
# Prelude Dart
!!! Note
This module builds on top of the lsp-module.
The dart module is powered by [lsp-dart](https://emacs-lsp.github.io/lsp-dart/).
Some features it provides:
- Flutter integration
- Tree views
- Run pub
- Debug
- Run tests
Some essential commands:
- `lsp-dart-pub-get` - Run pub get or flutter pub get on project root.
- `lsp-dart-pub-upgrade` - Run pub upgrade or flutter pub upgrade on project root.
- `lsp-dart-pub-outdated` - Run pub outdated or flutter pub outdated on project root.
- `lsp-dart-run-all-tests` - Run all tests from project.
- `lsp-dart-run-test-file` - Run all tests from current test buffer.

View file

@ -0,0 +1,33 @@
# Prelude Emacs Lisp
!!! Note
This module builds on top of the shared [Lisp Base](lisp.md) module.
## Elisp-mode
The module establishes some sensible defaults for `elisp-mode` and
shortens its modeline name to "EL".
It establishes a few extra keybidings (inspired by SLIME):
* `C-c C-z` (`prelude-visit-ielm`)
* `C-c C-c` (`eval-defun`)
* `C-c C-b` (`eval-buffer`)
The module also enables auto-recompilation of Elisp files on save.
## IELM
IELM is an Elisp REPL bundled with Emacs. Prelude tweaks a bit it's default
configuration to align it with the `elisp-mode` configuration.
## elisp-slime-nav
The module bundles [elisp-slime-nav](https://github.com/purcell/elisp-slime-nav),
which allows you to jump to definitions with `C-.` (use `C-,` to jump back) and describe a symbol with
`C-c C-d (C-)d`.
## Minibuffer evaluation
`smartparens-mode` is conditionally enabled for `eval-expression` (`M-:`) command.

56
docs/modules/erc.md Normal file
View file

@ -0,0 +1,56 @@
# Prelude ERC
ERC is a popular IRC client bundled with Emacs.
ERC is both powerful and complex, that's why Prelude bundles
some configuration for it, together with a few handy commands
like `start-irc` and `stop-irc`.
## Customizing Server list
If you want to join a list of servers on `M-x start-irc`, other than
the default list, please redefine the variable `my-fav-irc` as follows
in your personal config:
```emacs-lisp
(setq my-fav-irc '("irc.freenode.net"
"irc.oftc.net"
"irc.mozilla.org"
"irc.gnome.org"))
```
## Customizing Last Quit Message
If you want to customize your IRC Last Quit Message from *Asta la
vista* to something more funkier, please redefine `bye-irc-message` as
follows:
```emacs-lisp
(setq bye-erc-message "adios")
```
## Reading NickServ passwords from auth-source plugin
If you want to automatically authenticate while logging into IRC
servers set the `erc-prompt-for-password` to nil as follows:
```emacs-lisp
(setq erc-prompt-for-password nil)
```
Now you can set password in plaintext in `.authinfo` file in the netRC
format or you it encrypted in `.authinfo.gpg` file after setting up gpg
in Emacs.
## Opening all ERC buffers in a new perspective
Many a time when we start IRC with the `start-irc` command, all the
channels open in our existing workspace, which can be annoying to
some; especially to those who like to organize their buffers into
separate groups (perspectives). To avoid this scenario, it is better
to group all the ERC buffers into one perspective called `IRC` when
`start-irc` is called. To enable this set the `prelude-new-irc-persp`
variable to true as follows:
```emacs-lisp
(setq prelude-new-irc-persp t)
```

11
docs/modules/fsharp.md Normal file
View file

@ -0,0 +1,11 @@
# Prelude F#
!!! Note
This module builds on top of the shared [Programming](programming.md) module.
## F# mode
This module uses
[`fsharp-mode`](https://github.com/fsharp/emacs-fsharp-mode) and
`eglot-fsharp` with almost no extra configuration.

94
docs/modules/index.md Normal file
View file

@ -0,0 +1,94 @@
# Modules
!!! Note
Most modules are not currently documented. Helping out with their
documentation is a great way to contribute to the project!
Prelude provides extra functionality through modules. Some modules may
require extra steps to enable all functionality. These steps and the
functionality provided by these modules are documented on the
following links.
## What's a module?
Prelude modules are plain old Elisp libraries - there's absolutely nothing magical about them.
Most of them simply install a few Emacs packages and provide some sensible baseline configuration for them.
Here's a real example.
``` emacs-lisp
;;; prelude-ruby.el --- Emacs Prelude: A nice setup for Ruby (and Rails) devs.
;;
;;; Code:
(require 'prelude-programming)
(prelude-require-packages '(inf-ruby yari))
;; We never want to edit Rubinius bytecode
(add-to-list 'completion-ignored-extensions ".rbc")
(define-key 'help-command (kbd "R") 'yari)
(with-eval-after-load 'ruby-mode
(defun prelude-ruby-mode-defaults ()
(inf-ruby-minor-mode +1)
;; CamelCase aware editing operations
(subword-mode +1))
(setq prelude-ruby-mode-hook 'prelude-ruby-mode-defaults)
(add-hook 'ruby-mode-hook (lambda ()
(run-hooks 'prelude-ruby-mode-hook))))
(provide 'prelude-ruby)
;;; prelude-ruby.el ends here
```
To use a module you simple have to require it. No new concepts. No magic.
## Programming Language Modules
The following programming languages have enhanced support in Prelude:
- C/C++
- [Clojure](clojure.md)
- CoffeeScript
- [Common Lisp](common_lisp.md)
- CSS
- [Dart](dart.md)
- [Emacs Lisp](emacs_lisp.md)
- Erlang
- Elixir
- Go
- Haskell
- JavaScript
- LaTeX
- [Lisp Base](lisp.md) (common foundation for Lisp modules)
- LSP (common foundation for all modules relying on `lsp-mode`)
- Markdown
- OCaml
- Perl
- [Python](python.md)
- [Programming Base](programming.md) (common foundation for programming modules)
- [Ruby](ruby.md)
- Rust
- Scala
- [Scheme](scheme.md)
- SCSS
- Shell
- TypeScript
- Web
- XML
- YAML
## Other Modules
- [Company](company.md)
- [ERC](erc.md)
- evil
- helm
- ido
- ivy
- key-chord
- Org Mode

7
docs/modules/lisp.md Normal file
View file

@ -0,0 +1,7 @@
# Prelude Lisp
Basic shared configuration for Lisp-like programming languages. Currently
it does only two things:
* Enables `smartparens-strict-mode` in Lisp major modes and REPL buffers
* Enables `rainbow-delimiters` in Lisp major modes and REPL buffers

View file

@ -0,0 +1,15 @@
# Prelude Programming
Prelude's programming module enables some additional functionality
for `prog-mode` - the parent mode for all major programming modes in Emacs.
Here are some features it provides:
* spell-checking of comments (via `flyspell-prog-mode`)
* auto-pairing of delimiters like parentheses (via `smartparens`)
* visual ques for whitespace (via `whitespace-mode`)
* highlighting code annotations (via `hl-todo`)
* linter integration (via `flycheck`)
* showing current definition name in the modeline (via `which-func`)
Most of this boils down to enabling a bunch of minor modes in `prog-mode-hook`.

47
docs/modules/python.md Normal file
View file

@ -0,0 +1,47 @@
# Prelude Python
!!! Note
This module builds on top of the shared [Programming](programming.md) module.
## Python Mode
Emacs comes with Python programming support through the built-in
`python-mode`. Whenever you are editing Python code run `C-h m` to
look at the Python mode key bindings. Alternatively look at the
menu bar entries under Python. To toggle the menu bar press `F12`.
## Anaconda Mode
Prelude bundles the powerful
[anaconda-mode](https://github.com/pythonic-emacs/anaconda-mode),
which provides code navigation, documentation lookup and completion for Python.
Anaconda has integration with popular modes like `company` and `eldoc`.
## Syntax checking
Prelude ships with [Flycheck](https://github.com/flycheck/flycheck),
an on the fly syntax checker. Flycheck has support for two Python
syntax checkers, [Pylint](http://www.pylint.org/) and
[Flake8](http://flake8.readthedocs.org/en/latest/). In
order to have Flycheck support on the fly syntax checking for
Python you need to have either of these installed and accessible to
Emacs. In order to manually choose a checker run `C-c ! s`.
## Automatic insertion of file encoding comments
You can have Prelude auto-detect the encoding of a source buffer and
insert the appropriate `# coding:` comments. If you wish to enable
this, add the following to your configuration:
```emacs-lisp
(setq prelude-python-mode-set-encoding-automatically t)
```
!!! Note
Previously `prelude-python` had this feature enabled by default (up to Prelude 1.1), but
it is only necessary on Python 2, because Python 3 uses utf-8
as the default file encoding. In 2020 Python 2 became deprecated, so that
functionality became mostly obsolete.

25
docs/modules/ruby.md Normal file
View file

@ -0,0 +1,25 @@
# Prelude Ruby
!!! Note
This module builds on top of the shared [Programming](programming.md) module.
## Ruby Mode
Emacs comes with Ruby programming support through the built-in
`ruby-mode`. Whenever you are editing Ruby code run `C-h m` to
look at the Python mode key bindings. Alternatively look at the
menu bar entries under Ruby. To toggle the menu bar press `F12`.
Prelude enables `CamelCase` aware editing in Ruby code (via `subword-mode`).
## inf-ruby
The module bundles the [inf-ruby](https://github.com/nonsequitur/inf-ruby) package which allows you to run a Ruby
REPL (e.g. `irb` or `pry`) in an Emacs buffer and interact with it from
Ruby source buffers.
## yari
The module bundles the [yari](https://github.com/hron/yari.el) package which allows you to search in Ruby's RI
documentation. Use `C-h R` to invoke it.

28
docs/modules/scheme.md Normal file
View file

@ -0,0 +1,28 @@
# Prelude Scheme
!!! Note
This module builds on top of the shared [Lisp Base](lisp.md) module.
## lisp-mode
Not much to say here, as `scheme-mode` is configured to use Prelude's
default Lisp settings.
## Geiser
This module bundles [Geiser](https://www.nongnu.org/geiser/), a popular interactive
programming environment for Scheme. People familiar with Common Lisp's SLIME will
feel right at home with Geiser.
Note that Geiser supports many Scheme implementations:
* Guile 2.2 or better
* Chicken 4.8.0 or better
* MIT/GNU Scheme 9.1 or better
* Chibi Scheme 0.7 or better
* Chez Scheme 9.4 or better
* Gambit 4.9 or better
* Racket 6.0 or better
You can fire Geiser with `M-x geiser`.