## Manuellement

L’une des méthodes suivantes s’applique :

- Utiliser le script d’installation :
    ```sh
    # Vérifiez toujours le contenu du script avant de l’exécuter !
    $ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/skim-rs/skim/releases/latest/download/skim-installer.sh | sh
    ```
- Utiliser le binaire : téléchargez simplement [l’exécutable sk](https://github.com/skim-rs/skim/releases) directement.
- Installer depuis [crates.io](https://crates.io/) : `cargo install skim`
- Compiler manuellement :
    ```sh
    $ git clone --depth 1 [email protected]:skim-rs/skim.git ~/.skim
    $ cd ~/.skim
    $ cargo build --release
    $ # Ajoutez l’exécutable `target/release/sk` résultant à votre PATH
    ```

Vous aurez alors accès à :

- La page de manuel, que vous pouvez soit écrire dans le chemin approprié, soit exécuter `man --local-file <(sk --man)`
- Les complétions du shell (et les raccourcis clavier optionnels), en utilisant `source <(sk --shell \<shell> \[--shell-bindings])`, voir ci-dessous pour plus de détails

# Utilisation

Skim peut être utilisé soit comme un filtre général (similaire à `grep`), soit comme une
interface interactive pour exécuter des commandes.

## Comme plugin Vim (sur neovim, consultez [fzf-lua](https://github.com/ibhagwan/fzf-lua) avec le profil skim)

Via vim-plug (recommandé) :

Installez skim, puis :```vim
Plug 'skim-rs/skim'

Cette dernière commande vous permet de sélectionner des fichiers avec l'extension « .rs » et ouvre
vos sélections dans Vim — un véritable gain de temps pour les développeurs !

## En tant qu'interface interactive

`skim` peut invoquer d'autres commandes dynamiquement. Normalement, vous voudriez
l'intégrer avec [grep](https://www.gnu.org/software/grep/),
[ack](https://github.com/petdance/ack2),
[ag](https://github.com/ggreer/the_silver_searcher), ou
[rg](https://github.com/BurntSushi/ripgrep) pour rechercher des contenus dans un
répertoire de projet :```sh
# works with grep
sk --ansi -i -c 'grep -rI --color=always --line-number {q} .'
# works with ack
sk --ansi -i -c 'ack --color {q}'
# works with ag
sk --ansi -i -c 'ag --color {q}'
# works with rg
sk --ansi -i -c 'rg --color=always --line-number {q}'

#### Option 2 : Enregistrer dans un fichier à charger automatiquement au démarrage du shell```sh
# For bash, add to ~/.bashrc
echo 'source <(sk --shell bash)' >> ~/.bashrc  # Or save to ~/.bash_completion

# For zsh, add to ~/.zshrc
sk --shell zsh > ~/.zfunc/_sk  # Create ~/.zfunc directory and add to fpath in ~/.zshrc

# For fish, add to ~/.config/fish/completions/
sk --shell fish > ~/.config/fish/completions/sk.fish

Vous pouvez passer en mode `regex` dynamiquement en appuyant sur `Ctrl-R` (Rotate Mode).

## code de sortie

| Code de sortie | Signification                     |
|-----------|-------------------------------------|
| 0         | Sortie normale                     |
| 1         | Aucune correspondance trouvée      |
| 130       | Interrompu par Ctrl-C/Ctrl-G/ESC/etc... |

# Outils compatibles avec `skim`

Ces outils sont ou visent à être compatibles avec `skim` :

## [Plugin neovim fzf-lua](https://github.com/ibhagwan/fzf-lua)

Un plugin [neovim](https://neovim.io) permettant d'utiliser fzf et skim pour naviguer dans votre code.

Installez-le avec votre gestionnaire de paquets, en suivant le README. Par exemple, avec `lazy.nvim` :```lua
{
  "ibhagwan/fzf-lua",
  -- enable `sk` support instead of the default `fzf`
  opts = {'skim'}
}

## [extension sqlite](https://github.com/tzachar/sqlite_skim)

Un module chargeable `sqlite` qui active une fonction `skim_score` dans les
requêtes SQL.

# Personnalisation

La documentation ici n'est qu'un aperçu, veuillez consulter la page de manuel (`man sk`) pour une
liste complète des options.

## Keymap

Spécifiez les liaisons avec des paires séparées par des virgules (aucun espace autorisé). Par exemple :```sh
sk --bind 'alt-a:select-all,alt-d:deselect-all'

Skim respecte également la variable d'environnement `NO_COLOR`. Définissez-la à n'importe quelle valeur et `sk` (ainsi que de nombreuses autres applications de terminal) désactivera toute sortie colorée. Consultez [no-color.org](https://no-color.org/) pour plus de détails.

### Schémas de couleurs de base disponibles

Skim est livré avec plusieurs schémas de couleurs intégrés que vous pouvez utiliser comme point de départ :```sh
sk --color=dark      # Default dark theme (256 colors)
sk --color=light     # Light theme (256 colors)
sk --color=16        # Simple 16-color theme
sk --color=bw        # Minimal black & white theme (no colors, just styles)
sk --color=none      # Minimal black & white theme (no colors, no styles)
sk --color=molokai   # Molokai-inspired theme (256 colors)

Les couleurs peuvent être spécifiées de plusieurs manières :

- Couleurs ANSI (0-255) : `sk --color=fg:232,bg:255`
- Valeurs hexadécimales RGB : `sk --color=fg:#FF0000` (texte rouge)

### Options de personnalisation des couleurs disponibles

Les éléments d'interface suivants peuvent être personnalisés :

| Élément            | Description                                 | Exemple                        |
|--------------------|---------------------------------------------|--------------------------------|
| `fg`               | Couleur de premier plan du texte normal     | `--color=fg:232`               |
| `bg`               | Couleur d'arrière-plan du texte normal      | `--color=bg:255`               |
| `matched`          | Texte correspondant dans les résultats      | `--color=matched:108`          |
| `matched_bg`       | Arrière-plan du texte correspondant         | `--color=matched_bg:0`         |
| `current`          | Couleur de premier plan de la ligne actuelle| `--color=current:254`          |
| `current_bg`       | Couleur d'arrière-plan de la ligne actuelle | `--color=current_bg:236`       |
| `current_match`    | Texte correspondant dans la ligne actuelle  | `--color=current_match:151`    |
| `current_match_bg` | Arrière-plan du texte correspondant dans la ligne actuelle | `--color=current_match_bg:236` |
| `spinner`          | Couleur de l'indicateur de progression      | `--color=spinner:148`          |
| `info`             | Couleur de la ligne d'information           | `--color=info:144`             |
| `prompt`           | Couleur de l'invite                         | `--color=prompt:110`           |
| `cursor`           | Couleur du curseur                          | `--color=cursor:161`           |
| `selected`         | Couleur du marqueur d'élément sélectionné   | `--color=selected:168`         |
| `header`           | Couleur du texte d'en-tête                  | `--color=header:109`           |
| `border`           | Couleur de la bordure pour l'aperçu/disposition | `--color=border:59`        |

### Exemples```sh
# Use light theme but change the current line background
sk --color=light,current_bg:24

# Custom theme with multiple colors
sk --color=dark,matched:#00FF00,current:#FFFFFF,current_bg:#000080

# High contrast theme
sk --color=fg:232,bg:255,matched:160,current:255,current_bg:20

### Comment cela fonctionne-t-il ?

![Comment fonctionne le mode interactif de Skim](https://assets.kitploit.com/production/public/readmes/54416/5895df8cd6dbe8dfe20cafd1bf0b23fd690191710c00f811e110aba228b32a35/a7b995846d08eb2aa7f351371b38a9a35261eb393632363f62c6a67785f4038e-display-v1.webp)

- Skim accepte deux types de sources : la sortie d'une commande ou une entrée redirigée (piped input)
- Skim dispose de deux types d'invites : une invite de requête pour spécifier le motif de recherche et une
    invite de commande pour spécifier les « arguments » de la commande
- `-c` est utilisé pour spécifier la commande à exécuter et utilise par défaut `SKIM_DEFAULT_COMMAND`
- `-i` indique à skim d'ouvrir l'invite de commande au démarrage, qui affichera `c>` par défaut.

Pour affiner davantage les résultats renvoyés par la commande, appuyez sur
`Ctrl-Q` pour activer le mode interactif.

## Exécution de programmes externes

Vous pouvez configurer des raccourcis clavier pour lancer des processus externes sans quitter Skim (`execute`, `execute-silent`).```sh
# Press F1 to open the file with less without leaving skim
# Press CTRL-Y to copy the line to clipboard and aborts skim (requires pbcopy)
sk --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'

(Notez que [preview.sh](https://github.com/junegunn/fzf.vim/blob/master/bin/preview.sh) est un script qui affiche le contexte à partir de nomfichier:lignes:colonnes)

Vous obtenez des résultats comme ceci :

![aperçu de la démo](https://assets.kitploit.com/production/public/readmes/54416/b89dd1e40297ffc3fa4684c4a6d5dc9506c0eafdb881d4cea079ff843f1a271a/84156872f39354a97241078491506fee9f9962eda6628161f94f6f36ec2c79f9-display-v1.webp)

### Comment cela fonctionne-t-il ?

Si la commande d'aperçu est fournie via l'option `--preview`, skim remplacera
`{}` par la ligne actuellement surlignée entourée de guillemets simples, appellera
la commande pour obtenir la sortie, puis affichera cette sortie dans la fenêtre d'aperçu.

Parfois, vous n'avez pas besoin de la ligne entière pour invoquer la commande. Dans ce cas,
vous pouvez utiliser `{}`, `{1..}`, `{..3}` ou `{1..5}` pour sélectionner les champs. La
syntaxe est expliquée dans la section [Prise en charge des champs](#filds-support).

Enfin, vous pouvez configurer la position de la fenêtre d'aperçu avec `--preview-window` :
- `--preview-window up:30%` pour placer la fenêtre en position haute avec une hauteur
    de 30 % de la hauteur totale de skim.
- `--preview-window left:10:wrap` pour spécifier que `wrap` permet à la fenêtre
    d'aperçu de renvoyer à la ligne la sortie de la commande d'aperçu.
- `--preview-window wrap:hidden` pour masquer la fenêtre d'aperçu au démarrage ; elle
    peut ensuite être affichée via l'action `toggle-preview`.

## Prise en charge des champs

Normalement, seuls les utilisateurs de plugins ont besoin de comprendre cela.

Par exemple, vous disposez d'une source de données au format :```sh
<filename>:<line number>:<column number>

_Note sur les fonctionnalités_ :
    - la fonctionnalité `cli` est requise pour utiliser skim en tant qu'outil en ligne de commande, elle *ne devrait* pas être nécessaire lorsqu'on l'utilise comme bibliothèque.

### Utilisation de base

Ensuite, essayez d'exécuter cet exemple simple :```rust
extern crate skim;
use skim::prelude::*;
use std::io::Cursor;

pub fn main() {
    let options = SkimOptionsBuilder::default()
        .height("50%")
        .multi(true)
        .build()
        .unwrap();

    let input = "aaaaa\nbbbb\nccc".to_string();

    // `SkimItemReader` is a helper to turn any `BufRead` into a stream of `SkimItem`
    // `SkimItem` was implemented for `AsRef<str>` by default
    let item_reader = SkimItemReader::default();
    let items = item_reader.of_bufread(Cursor::new(input));

    // `run_with` would read and show items from the stream
    let selected_items = Skim::run_with(&options, Some(items))
        .map(|out| out.selected_items)
        .unwrap_or_else(|| Vec::new());

    for item in selected_items.iter() {
        println!("{}", item.output());
    }
}

Vous pouvez l’ajouter à votre `.bashrc` ou `.zshrc` si vous souhaitez qu’il soit utilisé par défaut.

## Certains fichiers ne sont pas affichés dans le plugin Vim

Si vous utilisez le plugin Vim et exécutez la commande `:SK`, vous constaterez peut-être que certains
de vos fichiers ne sont pas affichés.

Comme décrit dans [#3](https://github.com/skim-rs/skim/issues/3), dans le plugin
Vim, `SKIM_DEFAULT_COMMAND` est défini par défaut sur la commande :```vim
let $SKIM_DEFAULT_COMMAND = "git ls-tree -r --name-only HEAD || rg --files || ag -l -g \"\" || find ."

À l'intérieur de la VM, la racine du projet est montée sur `C:\vagrant` :```powershell
cd C:\vagrant
cargo build
cargo test

# Dépannage

Pour diagnostiquer ce qui se passe, vous pouvez définir la variable d'environnement `SKIM_LOG` ou l'option `--log-level` sur `debug` ou même `trace`, et définir la variable d'environnement `SKIM_LOG_FILE` ou l'option `--log-file` vers un chemin. Vous pouvez ensuite consulter ces journaux pendant ou après l'exécution pour mieux comprendre ce qui se passe. N'hésitez pas à ajouter ces journaux à un problème si vous avez besoin d'aide.

## Problèmes de saut de ligne avec nix, FreeBSD, termux

Si vous rencontrez des problèmes d'affichage comme :```bash
$ for n in {1..10}; do echo "$n"; done | sk
  0/10 0/0.> 10/10  10  9  8  7  6  5  4  3  2> 1

# Benchmarks

## Benchmark interactif (`cli`)

Le benchmark `cli` compare skim (ou tout binaire compatible) à d'autres versions ou à fzf en exécutant l'interface interactive dans une session tmux et en interrogeant la ligne d'état jusqu'à ce que le nombre de correspondances se stabilise. Ce n'est en aucun cas une mesure précise ou infaillible, mais cela présente l'avantage supplémentaire de comparer à `fzf` et de fournir des métriques de ressources (pic RSS et CPU).```sh
cargo bench --bench cli -- run                              # defaults: sk, 1 M items, query "test"
cargo bench --bench cli -- run sk -n 500000 -q foo              # bare name resolved via $PATH
cargo bench --bench cli -- run ./old/sk ./new/sk -r 5           # compare two binaries, 5 runs each
cargo bench --bench cli -- run sk -f input.txt -q search        # use an existing file
cargo bench --bench cli -- generate -f testdata.txt -n 2000000       # generate input file and exit
cargo bench --bench cli -- run sk --perf                            # record perf data (auto-named file)
cargo bench --bench cli -- run sk --strace                            # record strace data (auto-named file)
cargo bench --bench cli -- run sk -p perf.data                 # record perf data to perf.data
cargo bench --bench cli -- run sk -j                            # JSON output
cargo bench --bench cli -- run sk -r 3 -- --tiebreak=index     # pass extra flags to sk