From 1018867e92d94b4232c9bfd18b2d8124b50c6064 Mon Sep 17 00:00:00 2001 From: julien Date: Wed, 14 Oct 2026 10:35:57 +0200 Subject: [PATCH] first commit --- README.md | 474 +++++++++++++++++++++++++++++++++++++++++++ docs/docker.md | 73 +++++++ docs/neovim.md | 435 +++++++++++++++++++++++++++++++++++++++ docs/post-install.md | 105 ++++++++++ docs/ruby.md | 68 +++++++ docs/virt-manager.md | 74 +++++++ slackware.svg | 145 +++++++++++++ 7 files changed, 1374 insertions(+) create mode 100644 README.md create mode 100644 docs/docker.md create mode 100644 docs/neovim.md create mode 100644 docs/post-install.md create mode 100644 docs/ruby.md create mode 100644 docs/virt-manager.md create mode 100644 slackware.svg diff --git a/README.md b/README.md new file mode 100644 index 0000000..bf4b928 --- /dev/null +++ b/README.md @@ -0,0 +1,474 @@ +# Easy Slack ! + +**Easy Slack** rassemble mes notes pour installer et configurer simplement une **Slackware64 15.0**, que ce soit pour une station de travail avec KDE Plasma ou pour un serveur sans interface graphique. + +L'idée est de rester simple, aussi proche que possible des outils fournis par Slackware, tout en arrivant rapidement à un système agréable à utiliser. + +Ce guide ne couvre pas : + +* le Secure Boot ; +* les partitions chiffrées. + +## Table des matières + +* [Installation](#installation) +* [Configuration avant le premier démarrage](#configuration-avant-le-premier-démarrage) +* [Utilisateur](#utilisateur) +* [Station de travail KDE Plasma](#station-de-travail-kde-plasma) +* [Fin](#fin) +* [Après l'installation](#après-linstallation) +* [Maintenance](#maintenance) +* [SlackBuilds.org et sbopkg](#slackbuildsorg-et-sbopkg) +* [Outils supplémentaires](#outils-supplémentaires) +* [Documentation](#documentation) + +## Installation + +### Partitionner le(s) disque(s) + +Créez une nouvelle table de partitions GPT avec `fdisk`, puis partitionnez avec `cfdisk`. + +L'installateur se chargera de formater les partitions si nécessaire. + +Le schéma ci-dessous est celui que j'utilise. Une partition `/boot` séparée n'est pas obligatoire, mais je la conserve ici pour avoir une organisation identique entre mes machines. + +#### UEFI + +* 512M pour la partition EFI montée sur `/boot/efi` ; +* 1G pour la partition `/boot` ; +* le reste comme partition racine `/` ; +* éventuellement une partition `/home`. + +La partition EFI doit être de type **EFI System**. + +#### BIOS + +Sur une machine BIOS utilisant GPT : + +* 2M pour une partition **BIOS boot** non formatée ; +* 1G pour la partition `/boot` ; +* le reste comme partition racine `/` ; +* éventuellement une partition `/home`. + +La petite partition BIOS boot permet à GRUB de s'installer correctement sur un disque GPT. C'est notamment utile sur certains VPS. + +### Installer le système + +Lancez simplement : + +```sh +# setup +``` + +Et bienvenue dans les années 90, laissez-vous guider ! + +Au moment de choisir les séries de paquets : + +* pour une station de travail KDE Plasma, je n'installe pas `E/` ni `XFCE/` ; +* pour un serveur sans interface graphique, je n'installe pas `E/`, `KDE/`, `T/`, `TCL/`, `X/`, `XAP/`, `XFCE/` ni `Y/`. + +Slackware recommande une installation complète car elle ne gère pas automatiquement les dépendances. La sélection ci-dessus est donc volontaire et suppose de savoir quels composants seront utilisés. + +Passez également l'installation de `lilo` ou `elilo` : GRUB sera installé juste après. + +> Attention à ne pas redémarrer : le système n'est pas encore bootable. + +## Configuration avant le premier démarrage + +### Connexion + +Vérifiez la connexion Internet : + +```sh +# ping -c 3 www.slackware.com +``` + +Si le réseau n'est pas configuré, repérez l'interface adéquate : + +```sh +# ip addr +``` + +Puis lancez `dhcpcd` : + +```sh +# dhcpcd +``` + +La connexion devrait être fonctionnelle. + +### Chroot + +Le nouveau système est monté dans `/mnt` par l'installateur. + +Montez les pseudo-systèmes nécessaires : + +```sh +# mount -t proc /proc /mnt/proc +# mount --rbind /sys /mnt/sys +# mount --rbind /dev /mnt/dev +# mount --rbind /run /mnt/run +``` + +Copiez temporairement la configuration DNS : + +```sh +# cp /etc/resolv.conf /mnt/etc/resolv.conf +``` + +Puis entrez dans le nouveau système : + +```sh +# chroot /mnt /bin/bash +# source /etc/profile +``` + +En UEFI, vérifiez que la partition EFI est bien montée : + +```sh +# findmnt /boot/efi +``` + +### Locale + +Éditez le fichier : + +```sh +# nvi /etc/profile.d/lang.sh +``` + +et utilisez par exemple : + +```sh +export LANG=fr_FR.UTF-8 +``` + +Si `csh` ou un de ses dérivés est utilisé, adaptez également `/etc/profile.d/lang.csh`. + +### Synchronisation de l'heure + +Pour synchroniser automatiquement l'horloge avec le pool public NTP, éditez le fichier : + +```sh +# nvi /etc/ntp.conf +``` + +Le pilote d'horloge locale fourni dans le fichier par défaut est désormais déconseillé. Commentez : + +```text +#server 127.127.1.0 +#fudge 127.127.1.0 stratum 10 +``` + +et ajoutez à la place : + +```text +tos orphan 10 +``` + +Laissez les quatre lignes `server` du pool public commentées et ajoutez : + +```text +pool pool.ntp.org +tos minclock 4 minsane 3 +tos maxclock 8 +``` + +Dans la section des restrictions, conservez les règles existantes et ajoutez : + +```text +restrict source limited kod nomodify notrap noquery +``` + +Cette règle autorise les associations dynamiques créées par `pool` sans retirer les restrictions appliquées par défaut aux autres sources. + +Activez ensuite le service `ntpd` : + +```sh +# chmod +x /etc/rc.d/rc.ntpd +``` + +Il sera démarré automatiquement avec le système. Une fois le service lancé, les associations peuvent être vérifiées avec : + +```sh +# ntpq -n -p +``` + +### Slackpkg + +Éditez le fichier : + +```sh +# nvi /etc/slackpkg/mirrors +``` + +et décommentez un miroir pour Slackware64 15.0. Le miroir de redirection officiel convient très bien : + +```text +https://mirrors.slackware.com/slackware/slackware64-15.0/ +``` + +Puis initialisez `slackpkg` : + +```sh +# slackpkg update gpg +# slackpkg update +``` + +> **Important :** si, comme dans ce guide, vous n'avez pas installé certaines séries de paquets, pensez à les ajouter à la blacklist. Sans cela, `slackpkg install-new` pourra notamment proposer de nouveaux paquets appartenant à ces séries lors d'une prochaine mise à jour. + +Éditez le fichier : + +```sh +# nvi /etc/slackpkg/blacklist +``` + +et ajoutez par exemple pour une station de travail KDE Plasma : + +```text +e/ +xfce/ +``` + +ou pour un serveur sans interface graphique : + +```text +e/ +kde/ +t/ +tcl/ +x/ +xap/ +xfce/ +y/ +``` + +### Noyau `generic` + +Par défaut, le noyau `huge` est utilisé. Si vous préférez ne charger que les modules utiles à votre machine, vous pouvez passer au noyau `generic`. Slackware fournit pour cela `geninitrd`, qui génère `/boot/initrd.gz` pour le noyau pointé par `/boot/vmlinuz-generic` : + +```sh +# geninitrd +``` + +Après cette commande, il faut normalement exécuter `grub-mkconfig` afin d'adapter la configuration de GRUB… mais comme GRUB n'est pas encore installé, la suite arrive juste après ! + +### GRUB + +#### UEFI + +```sh +# grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi +``` + +#### BIOS + +Installez GRUB sur le disque entier, et non sur une partition : + +```sh +# grub-install --target=i386-pc /dev/sda +``` + +Sur un VPS, le disque peut par exemple être `/dev/vda`, et sur un NVMe `/dev/nvme0n1`. + +Générez ensuite le menu : + +```sh +# grub-mkconfig -o /boot/grub/grub.cfg +``` + +## Utilisateur + +Créez le premier utilisateur : + +```sh +# adduser +``` + +## Station de travail KDE Plasma + +Les réglages suivants concernent uniquement une station de travail avec interface graphique. + +### Clavier X11 + +Même si **Plasma (Wayland)** est utilisé, X11 reste disponible comme solution de repli. Configurez donc également sa disposition de clavier. + +Slackware 15.0 fournit deux fichiers de configuration, l'un pour `evdev` et l'autre pour `libinput`. + +Copiez-les dans `/etc` : + +```sh +# cp /usr/share/X11/xorg.conf.d/90-keyboard-layout-evdev.conf /etc/X11/xorg.conf.d/ +# cp /usr/share/X11/xorg.conf.d/91-keyboard-layout-libinput.conf /etc/X11/xorg.conf.d/ +``` + +Puis éditez les deux fichiers et remplacez : + +```text +Option "XkbLayout" "us" +``` + +par : + +```text +Option "XkbLayout" "fr" +``` + +Le réglage du clavier de la console, choisi pendant l'installation, est indépendant de celui de X11. + +### Démarrage graphique + +Éditez `/etc/inittab` : + +```sh +# nvi /etc/inittab +``` + +et remplacez : + +```text +id:3:initdefault: +``` + +par : + +```text +id:4:initdefault: +``` + +## Fin + +C'est terminé ! Vous pouvez sortir du `chroot` et redémarrer la machine : + +```sh +# exit +# reboot +``` + +Au premier démarrage, résistez à la tentation d'installer quoi que ce soit : commencez par mettre Slackware 15.0 à jour. Elle a probablement quelques bricoles à rattraper depuis 2022 ! + +## Après l'installation + +Quelques réglages propres à mes stations de travail KDE Plasma sont regroupés dans [docs/post-install.md](docs/post-install.md). + +## Maintenance + +### Mise à jour + +Pour une mise à jour complète de Slackware 15.0 : + +```sh +# slackpkg update +# slackpkg install-new +# slackpkg upgrade-all +``` + +`slackpkg clean-system` permet ensuite de retirer les paquets qui ne font plus partie de Slackware. Examinez attentivement la liste proposée : les paquets tiers y apparaissent également s'ils ne sont pas blacklistés. + +```sh +# slackpkg clean-system +``` + +### Mise à jour du noyau + +> **Important :** ne redémarrez pas avec un noyau `generic` mis à jour avant d'avoir régénéré l'initrd. + +Avant de redémarrer : + +```sh +# geninitrd +# grub-mkconfig -o /boot/grub/grub.cfg +``` + +## SlackBuilds.org et sbopkg + +Vous souhaitez des logiciels supplémentaires ? + +Faites un petit tour sur [SlackBuilds.org](https://slackbuilds.org/), qui fournit des SlackBuilds validés pour Slackware 15.0. + +> Les SlackBuilds sont des « recettes » pour compiler les programmes sous Slackware. + +Il est possible de les utiliser directement, mais la gestion manuelle des dépendances devient vite fastidieuse. Pour simplifier les choses, plusieurs outils existent. J'utilise `sbopkg`. + +Cet outil est disponible [ici](https://www.sbopkg.org/downloads.php). Téléchargez le paquet, puis installez-le avec : + +```sh +# installpkg sbopkg-*.tgz +``` + +Synchronisez le dépôt : + +```sh +# sbopkg -r +``` + +Pour éviter que les paquets SlackBuilds.org soient proposés par `slackpkg clean-system`, décommentez dans `/etc/slackpkg/blacklist` : + +```text +[0-9]+_SBo +``` + +Ajoutez également `sbopkg` à la blacklist pour conserver ce paquet. + +### Installer des logiciels + +Pour installer un paquet SlackBuilds.org sans dépendances supplémentaires : + +```sh +# sbopkg -i +``` + +Si des dépendances sont requises, générez d'abord une queue : + +```sh +# sqg -p +``` + +La queue est enregistrée dans `/var/lib/sbopkg/queues` et contient les dépendances dans le bon ordre. + +Relancez ensuite : + +```sh +# sbopkg -i +``` + +Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre. + +### Mettre à jour les logiciels installés + +Synchronisez d'abord le dépôt local, puis recherchez les mises à jour disponibles : + +```sh +# sbopkg -r +# sbopkg -c +``` + +Créez ensuite une queue contenant les paquets à mettre à jour : + +```sh +# sqg -p "" -o updates +# sbopkg -i updates +``` + +`sqg` ajoute automatiquement les dépendances nécessaires et les place dans le bon ordre. + +Le fichier `updates.sqf` peut être supprimé et recréé à chaque mise à jour. + +> `sbopkg -c` signale des mises à jour potentielles. Consultez le `README` du SlackBuild si une version nécessite une procédure particulière. + +## Outils supplémentaires + +* [Ruby avec rbenv depuis SlackBuilds.org](docs/ruby.md) +* [Neovim pour Ruby depuis SlackBuilds.org](docs/neovim.md) +* [Docker depuis SlackBuilds.org](docs/docker.md) +* [virt-manager depuis SlackBuilds.org](docs/virt-manager.md) + +## Documentation + +* [Installation de Slackware](https://docs.slackware.com/slackware:install) +* [Guide du débutant Slackware](https://docs.slackware.com/slackware:beginners_guide) +* [Slackpkg](https://docs.slackware.com/slackware:slackpkg) +* [Localisation](https://docs.slackware.com/slackware:localization) +* [Configuration du clavier](https://docs.slackware.com/howtos:window_managers:keyboard_layout) +* [SlackBuilds.org pour Slackware 15.0](https://slackbuilds.org/repository/15.0/) +* [sbopkg](https://www.sbopkg.org/) diff --git a/docs/docker.md b/docs/docker.md new file mode 100644 index 0000000..16f815a --- /dev/null +++ b/docs/docker.md @@ -0,0 +1,73 @@ +# Docker depuis SlackBuilds.org + +> Nécessite `sbopkg`. + +Commencez par générer la queue des dépendances : + +```sh +# sqg -p docker-cli +``` + +`docker-cli` dépend de `docker`. La queue ajoutera aussi ses dépendances, notamment `tini`, `containerd` et `runc`. + +Lancez ensuite : + +```sh +# sbopkg -i docker-cli +``` + +Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre. + +Pour utiliser Docker sans passer directement par le compte `root`, créez le groupe recommandé par le SlackBuild et ajoutez-y votre utilisateur : + +```sh +# groupadd -r -g 281 docker +# usermod -a -G docker +``` + +> **Important :** l'appartenance au groupe `docker` donne en pratique des privilèges équivalents à ceux de `root` sur la machine. + +Rendez ensuite le service exécutable et démarrez-le : + +```sh +# chmod +x /etc/rc.d/rc.docker +# /etc/rc.d/rc.docker start +``` + +Déconnectez-vous puis reconnectez-vous avant de tester : + +```sh +$ docker run hello-world +``` + +Pour démarrer Docker automatiquement avec le système, ajoutez dans `/etc/rc.d/rc.local` : + +```sh +# Docker +if [ -x /etc/rc.d/rc.docker ]; then + /etc/rc.d/rc.docker start +fi +``` + +Éditez ensuite `/etc/rc.d/rc.local_shutdown` ; le fichier sera créé s'il n'existe pas : + +```sh +# nvi /etc/rc.d/rc.local_shutdown +``` + +Puis ajoutez : + +```sh +# Docker +if [ -x /etc/rc.d/rc.docker ]; then + /etc/rc.d/rc.docker stop +fi +``` + +Enfin, rendez le script exécutable : + +```sh +# chmod +x /etc/rc.d/rc.local_shutdown +``` + +[Retour au guide principal](../README.md) diff --git a/docs/neovim.md b/docs/neovim.md new file mode 100644 index 0000000..61b49bc --- /dev/null +++ b/docs/neovim.md @@ -0,0 +1,435 @@ +# Neovim pour Ruby depuis SlackBuilds.org + +> Nécessite `sbopkg`. + +Neovim est un éditeur de texte modal dérivé de Vim. La configuration ci-dessous reste volontairement simple : Telescope est utilisé pour naviguer entre les fichiers et les buffers, `ripgrep` pour rechercher dans le projet, Grug Far pour rechercher et remplacer dans plusieurs fichiers, `nvim-autopairs` pour fermer automatiquement les paires, et le client LSP intégré de Neovim pour Ruby, la complétion et les signatures de méthodes. + +## Installation + +Neovim est disponible sur SlackBuilds.org. Générez la queue des dépendances : + +```sh +# sqg -p neovim +``` + +Puis lancez l'installation : + +```sh +# sbopkg -i neovim +``` + +Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre. + +Installez également `ripgrep`, utilisé par Telescope pour rechercher dans le projet : + +```sh +# sqg -p ripgrep +# sbopkg -i ripgrep +``` + +Sous Wayland, installez `wl-clipboard` pour permettre à Neovim d'utiliser le presse-papiers système : + +```sh +# sbopkg -i wl-clipboard +``` + +Pour un affichage homogène des symboles, vous pouvez également installer JetBrains Mono Nerd Font : + +```sh +# sbopkg -i ttf-nerd-fonts-jetbrains-mono +``` + +La variante **JetBrainsMono Nerd Font Mono** est adaptée à l'affichage dans un terminal. + +Vérifiez ensuite les installations : + +```sh +$ nvim --version +$ rg --version +``` + +## Configuration + +Créez le dossier de configuration : + +```sh +$ mkdir -p ~/.config/nvim +``` + +Créez ou éditez `~/.config/nvim/init.lua` : + +```sh +$ nvi ~/.config/nvim/init.lua +``` + +Utilisez cette configuration : + +```lua +-- Telescope remplace Netrw. +vim.g.loaded_netrw = 1 +vim.g.loaded_netrwPlugin = 1 + +-- Leader +vim.g.mapleader = " " +vim.g.maplocalleader = "," + +-- Affichage +vim.opt.number = true +vim.opt.signcolumn = "yes" +vim.opt.cursorline = true +vim.opt.splitkeep = "screen" +vim.opt.splitright = true +vim.opt.splitbelow = true +vim.opt.shortmess:append("I") +vim.opt.winborder = "rounded" +vim.cmd.colorscheme("retrobox") + +-- Apparence homogène des menus et fenêtres flottantes. +vim.api.nvim_set_hl(0, "NormalFloat", { link = "Pmenu" }) +vim.api.nvim_set_hl(0, "FloatBorder", { link = "PmenuBorder" }) +vim.api.nvim_set_hl(0, "TelescopeNormal", { link = "Pmenu" }) +vim.api.nvim_set_hl(0, "TelescopeBorder", { link = "PmenuBorder" }) +vim.api.nvim_set_hl(0, "TelescopeSelection", { link = "PmenuSel" }) + +-- Indentation +vim.opt.expandtab = true +vim.opt.shiftwidth = 2 +vim.opt.tabstop = 2 + +-- Presse-papiers système +vim.opt.clipboard = "unnamedplus" + +-- Autocomplétion de la ligne de commande +vim.opt.wildmode = "noselect:lastused,full" + +vim.api.nvim_create_autocmd("CmdlineChanged", { + pattern = { ":", "/", "?" }, + callback = function() + vim.fn.wildtrigger() + end, +}) + +-- Plugins +vim.pack.add({ + "https://github.com/nvim-lua/plenary.nvim", + "https://github.com/MagicDuck/grug-far.nvim", + "https://github.com/windwp/nvim-autopairs", + { + src = "https://github.com/nvim-telescope/telescope.nvim", + version = "v0.2.1", + }, +}) + +-- Auto-fermeture des paires +local npairs = require("nvim-autopairs") + +npairs.setup({ + map_cr = false, +}) + +-- Telescope +local builtin = require("telescope.builtin") + +require("telescope").setup({ + defaults = { + preview = false, + }, +}) + +vim.keymap.set("n", "f", builtin.find_files, { + desc = "Files", +}) + +vim.keymap.set("n", "b", builtin.buffers, { + desc = "Buffers", +}) + +vim.keymap.set("n", "g", builtin.live_grep, { + desc = "Grep", +}) + +vim.keymap.set("n", "w", builtin.grep_string, { + desc = "Word", +}) + +vim.keymap.set("n", "l", builtin.resume, { + desc = "Last search", +}) + +vim.keymap.set("n", "d", builtin.diagnostics, { + desc = "Diagnostics", +}) + +-- Grug Far +vim.keymap.set({ "n", "x" }, "r", function() + require("grug-far").open() +end, { + desc = "Replace", +}) + +-- Ouvre Telescope au démarrage sauf si un fichier est explicitement ouvert. +vim.api.nvim_create_autocmd("VimEnter", { + once = true, + callback = function() + local argc = vim.fn.argc() + + if argc == 1 and vim.fn.isdirectory(vim.fn.argv(0)) == 1 then + vim.api.nvim_set_current_dir(vim.fn.fnamemodify(vim.fn.argv(0), ":p")) + vim.cmd.enew() + elseif argc > 0 then + return + end + + builtin.find_files() + end, +}) + +-- Ruby LSP +local capabilities = vim.lsp.protocol.make_client_capabilities() + +-- Active la surveillance des fichiers par Ruby LSP sous Linux. +capabilities.workspace.didChangeWatchedFiles.dynamicRegistration = true + +vim.lsp.config("ruby_lsp", { + cmd = { "ruby-lsp" }, + filetypes = { "ruby" }, + root_markers = { "Gemfile", ".git" }, + capabilities = capabilities, + -- Contournement temporaire pour Ruby LSP 0.26.11 : dans un projet Ruby + -- plat, Ruby Indexer peut construire le motif {}/**/*.rb et indexer un + -- même fichier sous deux chemins différents. Cette exclusion neutralise + -- uniquement ce motif ; les fichiers Ruby restent indexés normalement. + init_options = { + indexing = { + excludedPatterns = { "{}/**/*.rb" }, + }, + }, +}) + +vim.lsp.enable("ruby_lsp") + +-- Complétion Ruby LSP +vim.opt.completeopt = { "menuone", "noselect" } +vim.opt.pumheight = 8 +vim.opt.pumwidth = 36 +vim.opt.pummaxwidth = 72 +vim.opt.pumborder = "rounded" + +vim.api.nvim_create_autocmd("LspAttach", { + callback = function(event) + local client = vim.lsp.get_client_by_id(event.data.client_id) + if client and client:supports_method("textDocument/completion") then + vim.lsp.completion.enable(true, client.id, event.buf) + end + end, +}) + +vim.api.nvim_create_autocmd("InsertCharPre", { + callback = function() + vim.lsp.completion.get() + end, +}) + +vim.keymap.set("i", "", function() + if vim.fn.pumvisible() == 1 then + local selected = vim.fn.complete_info({ "selected" }).selected + if selected == -1 then + return "" + end + return "" + end + return "" +end, { expr = true }) + +vim.keymap.set("i", "", function() + if vim.fn.pumvisible() == 1 then + local selected = vim.fn.complete_info({ "selected" }).selected + if selected ~= -1 then + return npairs.esc("") + end + end + + return npairs.autopairs_cr() +end, { + expr = true, + replace_keycodes = false, +}) +``` + +Le bloc `init_options` contient un contournement temporaire pour Ruby LSP 0.26.11 : dans certains petits projets Ruby plats, Ruby Indexer peut construire le motif `{}/**/*.rb` et indexer un même fichier sous deux chemins différents. Cette exclusion neutralise uniquement ce motif ; les fichiers Ruby restent indexés normalement. Lorsque le problème sera corrigé dans Ruby LSP/Ruby Indexer, le bloc `init_options` pourra être retiré. + +Neovim gère les plugins avec `vim.pack`. `plenary.nvim` est une dépendance de Telescope, `nvim-autopairs` ferme automatiquement les parenthèses, crochets, accolades et guillemets, et Grug Far utilise `ripgrep` pour la recherche et le remplacement. La complétion Ruby, les signatures de méthodes et la navigation LSP utilisent directement les fonctions intégrées à Neovim, sans plugin de complétion supplémentaire. + +Le réglage `vim.opt.clipboard = "unnamedplus"` relie le registre par défaut de Neovim au presse-papiers système. Sous Wayland, Neovim utilise `wl-copy` et `wl-paste` fournis par `wl-clipboard`. Vous pouvez vérifier le fournisseur détecté avec : + +```text +:checkhealth vim.provider +``` + +La section `Clipboard` doit indiquer qu'un outil de presse-papiers a été trouvé. + +### Mise à jour des plugins + +Pour rechercher les nouvelles versions des plugins gérés par `vim.pack` : + +```text +:packupdate +``` + +Vérifiez les changements proposés, puis utilisez `:write` pour les accepter. Pour contrôler l'état du gestionnaire de plugins : + +```text +:checkhealth vim.pack +``` + +## Ruby + +### Ruby LSP + +Installez `ruby-lsp` avec le Ruby utilisé par votre environnement : + +```sh +$ gem install ruby-lsp +``` + +Vérifiez ensuite le client LSP dans Neovim : + +```text +:checkhealth vim.lsp +``` + +### RuboCop + +Installez RuboCop avec le Ruby utilisé par votre environnement : + +```sh +$ gem install rubocop +``` + +Vérifiez son installation : + +```sh +$ rubocop -V +``` + +Créez `~/.rubocop.yml` pour activer automatiquement les nouvelles règles ajoutées comme `pending` par RuboCop : + +```sh +$ nvi ~/.rubocop.yml +``` + +Ajoutez ensuite : + +```yaml +AllCops: + NewCops: enable +``` + +RuboCop est utilisé manuellement pour mettre en forme le code et effectuer des vérifications ciblées. + +Pour appliquer uniquement les règles de mise en forme à l'ensemble du projet : + +```sh +$ rubocop --only Layout -A +``` + +Pour afficher uniquement les remarques de style : + +```sh +$ rubocop --only Style --format simple +``` + +Pour rechercher les ambiguïtés et erreurs potentielles signalées par les règles `Lint` : + +```sh +$ rubocop --lint --format simple +``` + +## Utilisation + +Placez-vous dans le dossier du projet et lancez Neovim : + +```sh +$ cd ~/src/projet +$ nvim . +``` + +Sans fichier explicitement indiqué, Telescope s'ouvre directement. Si un fichier est passé sur la ligne de commande, Neovim l'ouvre normalement : + +```sh +$ nvim lib/game.rb +``` + +Les commandes suivantes suffisent pour commencer : + +| Commande | Action | +| --- | --- | +| `i` | Passer en mode insertion | +| `Esc` | Revenir en mode normal | +| `v` | Commencer une sélection visuelle | +| `y` (mode visuel) | Copier la sélection dans le presse-papiers système | +| `yy` | Copier la ligne courante dans le presse-papiers système | +| `p` | Coller depuis le presse-papiers système | +| `:w` | Enregistrer | +| `:q` | Quitter | +| `Space f` | Rechercher et ouvrir un fichier du projet | +| `Space b` | Afficher les buffers ouverts | +| `Space g` | Rechercher du texte dans le projet avec `ripgrep` | +| `Space w` | Rechercher dans le projet le mot sous le curseur | +| `Space l` | Reprendre la dernière vue Telescope | +| `Space d` | Afficher les diagnostics connus par Neovim avec Telescope | +| `Space r` | Ouvrir Grug Far pour rechercher et remplacer | +| `Ctrl-]` | Aller à la définition | +| `Ctrl-t` | Revenir après un saut vers une définition | +| `Ctrl-s` | Afficher la signature de la méthode en mode insertion (raccourci LSP natif) | +| `Tab` | Accepter la proposition sélectionnée, ou la première proposition si aucune ne l'est | +| `Entrée` | Accepter la proposition sélectionnée, sinon insérer une nouvelle ligne | +| `u` | Annuler | + +### Grug Far + +`Space r` ouvre Grug Far dans un split vertical. En mode visuel, la sélection courante est utilisée pour préremplir le texte recherché. + +Les raccourcis principaux dans Grug Far sont : + +| Commande | Action | +| --- | --- | +| `,r` | Appliquer le remplacement | +| `,c` | Fermer Grug Far | +| `Entrée` | Ouvrir l'emplacement du résultat sous le curseur | + +La virgule correspond ici à ``, défini dans la configuration avec `vim.g.maplocalleader = ","`. + +Pour vérifier l'installation ou diagnostiquer un problème : + +```text +:checkhealth grug-far +``` + +Dans Telescope : + +| Commande | Action | +| --- | --- | +| `Ctrl-n` ou `↓` | Résultat suivant | +| `Ctrl-p` ou `↑` | Résultat précédent | +| `Entrée` | Ouvrir le résultat | +| `Ctrl-v` | Ouvrir dans un split vertical | +| `Ctrl-x` | Ouvrir dans un split horizontal | +| `Ctrl-t` | Ouvrir dans un nouvel onglet | +| `Ctrl-c` | Fermer Telescope | + +La ligne de commande de Neovim propose automatiquement les complétions lorsque vous saisissez une commande après `:`. + +## Ignorer des fichiers du projet + +Pour masquer certains fichiers ou dossiers dans les recherches de Telescope sans modifier `.gitignore`, créez un fichier `.rgignore` à la racine du projet. Cette règle reste propre aux recherches locales et ne change pas les fichiers suivis par Git. + +Par exemple, pour ignorer le dossier `doc/` : + +```sh +$ printf 'doc/\n' > .rgignore +``` + +`ripgrep` prendra ce fichier en compte pour les recherches effectuées par Telescope lorsqu'il est utilisé comme moteur de recherche. + +[Retour au guide principal](../README.md) diff --git a/docs/post-install.md b/docs/post-install.md new file mode 100644 index 0000000..0c0082f --- /dev/null +++ b/docs/post-install.md @@ -0,0 +1,105 @@ +# Après l'installation + +Quelques rappels correspondant à ma configuration et à mes usages habituels après une nouvelle installation sur une station de travail KDE Plasma. Ces étapes ne sont pas nécessaires dans tous les cas. + +## Configuration de Plasma + +Dans SDDM, sélectionnez la session **Plasma (Wayland)** avant de vous connecter. + +Quelques réglages correspondant à mes préférences habituelles dans **Configuration du système** : + +* **Apparence** → **Thème global** : sélectionner **Breeze sombre** ; +* **Matériel** → **Affichage et écran** → **Couleur de nuit** : cocher **Activer la couleur de nuit** ; +* **Matériel** → **Périphériques d'entrée** → **Clavier** → **Dispositions** : activer **Configurer les dispositions**, puis ajouter **Français** ; +* **Espace de travail** → **Comportement de l'espace de travail** → **Bords de l'écran** : désactiver les actions configurées dans les coins ; +* **Espace de travail** → **Comportement de l'espace de travail** → **Comportement général** : pour **Cliquer sur des fichiers ou des dossiers**, choisir **Les sélectionne** afin d'utiliser un clic pour sélectionner et un double-clic pour ouvrir ; +* **Espace de travail** → **Comportement de l'espace de travail** → **Bureaux virtuels** : ajouter un deuxième bureau et le nommer **Bureau 2**. + +Et également dans l'émulateur de terminal **Konsole** → **Configuration** : désactiver **Afficher la barre de menus**. + +## Icône Slackware pour le menu Plasma + +Depuis la racine du dépôt, installez le fichier `slackware.svg` dans les icônes système : + +```sh +# mkdir -p /usr/local/share/icons +# cp slackware.svg /usr/local/share/icons/slackware.svg +``` + +Dans Plasma, éditez ensuite le lanceur d'applications et choisissez `/usr/local/share/icons/slackware.svg` comme icône. + +## KMix + +Faites un clic droit sur l'icône de volume de KMix, puis ouvrez **Configurer KMix** → **Démarrage** et décochez **Démarrer KMix au démarrage du bureau**. + +Faites ensuite de nouveau un clic droit sur l'icône de KMix et choisissez **Quitter**. + +## HPLIP Systray + +Pour empêcher l'applet HPLIP de se lancer avec Plasma : + +```sh +$ mkdir -p ~/.config/autostart +$ cp /etc/xdg/autostart/hplip-systray.desktop ~/.config/autostart/ +$ echo 'Hidden=true' >> ~/.config/autostart/hplip-systray.desktop +``` + +Cette modification désactive uniquement l'icône de la zone de notification pour l'utilisateur courant. Elle prend effet après reconnexion. + +## SSH + +Copiez les clés SSH dans `~/.ssh` en respectant les droits suivants : + +```text +[drwx------] ~/.ssh/ +├── [-rw-------] id_ed25519 +└── [-rw-r--r--] id_ed25519.pub +``` + +Si nécessaire : + +```sh +$ chmod 700 ~/.ssh +$ chmod 600 ~/.ssh/id_ed25519 +$ chmod 644 ~/.ssh/id_ed25519.pub +``` + +> Les droits de la clé privée doivent être correctement définis pour qu'OpenSSH l'accepte. + +## Git + +Configurez votre nom et votre adresse e-mail : + +```sh +$ git config --global user.name "John Doe" +$ git config --global user.email johndoe@example.com +``` + +Pour vérifier la configuration : + +```sh +$ git config --global --list +``` + +## KeePassXC + +> Nécessite `sbopkg`. + +Installez KeePassXC et ses dépendances : + +```sh +# sqg -p keepassxc +# sbopkg -i keepassxc +``` + +Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre. + +Pensez ensuite à copier la base de données KeePassXC. + +Et pour finir, assurez-vous qu'elle n'est visible que par votre utilisateur : + +```sh +$ chmod 600 ~/ +``` + +[Retour au guide principal](../README.md) diff --git a/docs/ruby.md b/docs/ruby.md new file mode 100644 index 0000000..25cc55f --- /dev/null +++ b/docs/ruby.md @@ -0,0 +1,68 @@ +# Ruby avec rbenv depuis SlackBuilds.org + +> Nécessite `sbopkg`. + +Slackware 15.0 fournit Ruby 3.0.7. Si vous souhaitez utiliser une version plus récente sans remplacer le paquet système, installez `rbenv` et `ruby-build` depuis SlackBuilds.org : + +```sh +# sbopkg -i rbenv +# sbopkg -i ruby-build +``` + +Initialisez ensuite `rbenv` pour votre shell : + +```sh +$ rbenv init +``` + +La commande ajoute automatiquement l'initialisation nécessaire au fichier de démarrage de Bash. Déconnectez-vous puis reconnectez-vous à votre session pour prendre en compte la modification. + +Vérifiez que les outils sont bien disponibles : + +```sh +$ rbenv --version +$ ruby-build --version +``` + +Vous pouvez maintenant afficher les versions de Ruby disponibles : + +```sh +$ rbenv install -l +``` + +Installez ensuite celle que vous souhaitez utiliser, par exemple : + +```sh +$ rbenv install 4.0.7 +``` + +Pour en faire la version par défaut pour votre utilisateur : + +```sh +$ rbenv global 4.0.7 +``` + +## Vérification + +Vérifiez enfin la version utilisée : + +```sh +$ ruby -v +$ command -v ruby +``` + +Avec `rbenv` actif, `ruby` doit normalement pointer vers : + +```text +/home//.rbenv/shims/ruby +``` + +Le Ruby fourni par Slackware reste installé dans `/usr/bin/ruby`. `rbenv` ne remplace pas le paquet système : il place simplement ses propres *shims* en tête du `PATH` pour le shell de l'utilisateur. + +Pour vérifier séparément la version système : + +```sh +$ /usr/bin/ruby -v +``` + +[Retour au guide principal](../README.md) diff --git a/docs/virt-manager.md b/docs/virt-manager.md new file mode 100644 index 0000000..05a6a68 --- /dev/null +++ b/docs/virt-manager.md @@ -0,0 +1,74 @@ +# virt-manager depuis SlackBuilds.org + +> Nécessite `sbopkg`. + +Pour utiliser virt-manager avec QEMU/KVM, installez **QEMU** en plus de virt-manager : `qemu` n'est pas une dépendance déclarée de `virt-manager`. + +Commencez par générer les queues de dépendances : + +```sh +# sqg -p qemu +# sqg -p virt-manager +``` + +Installez d'abord QEMU : + +```sh +# sbopkg -i qemu +``` + +Si `sbopkg` trouve à la fois le paquet et une queue du même nom, choisissez **Q** pour utiliser la queue et installer les dépendances dans le bon ordre. Faites ensuite la même chose pour virt-manager : + +```sh +# sbopkg -i virt-manager +``` + +Avec les options par défaut des SlackBuilds, `libvirt` et QEMU utilisent le groupe `users`. Pour permettre à un utilisateur normal d'utiliser virt-manager, décommentez ou réglez dans `/etc/libvirt/libvirtd.conf` : + +```text +unix_sock_group = "users" +unix_sock_rw_perms = "0770" +``` + +L'utilisateur doit bien sûr appartenir au groupe choisi. + +Rendez ensuite le service exécutable et démarrez-le : + +```sh +# chmod +x /etc/rc.d/rc.libvirt +# /etc/rc.d/rc.libvirt start +``` + +Pour démarrer libvirt automatiquement avec le système, ajoutez dans `/etc/rc.d/rc.local` : + +```sh +# Libvirt +if [ -x /etc/rc.d/rc.libvirt ]; then + /etc/rc.d/rc.libvirt start +fi +``` + +Éditez ensuite `/etc/rc.d/rc.local_shutdown` ; le fichier sera créé s'il n'existe pas : + +```sh +# nvi /etc/rc.d/rc.local_shutdown +``` + +Puis ajoutez : + +```sh +# Libvirt +if [ -x /etc/rc.d/rc.libvirt ]; then + /etc/rc.d/rc.libvirt stop +fi +``` + +Enfin, rendez le script exécutable : + +```sh +# chmod +x /etc/rc.d/rc.local_shutdown +``` + +> `rc.libvirt stop` effectue par défaut un `managedsave` des machines virtuelles encore actives. Prévoyez donc suffisamment d'espace disque pour sauvegarder leur mémoire. + +[Retour au guide principal](../README.md) diff --git a/slackware.svg b/slackware.svg new file mode 100644 index 0000000..0323345 --- /dev/null +++ b/slackware.svg @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + +