## Manualmente

Si applica uno dei seguenti casi:

- Utilizzando lo script di installazione:
    ```sh
    # Controlla sempre il contenuto dello script prima di eseguirlo!
    $ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/skim-rs/skim/releases/latest/download/skim-installer.sh | sh
    ```
- Utilizzando il binario: scarica semplicemente [l'eseguibile sk](https://github.com/skim-rs/skim/releases) direttamente.
- Installazione da [crates.io](https://crates.io/): `cargo install skim`
- Compilazione manuale:
    ```sh
    $ git clone --depth 1 [email protected]:skim-rs/skim.git ~/.skim
    $ cd ~/.skim
    $ cargo build --release
    $ # Aggiungi l'eseguibile `target/release/sk` risultante al tuo PATH
    ```

Avrai quindi accesso a:

- La pagina man, che puoi scrivere nel percorso corretto oppure eseguire `man --local-file <(sk --man)`
- Il completamento della shell (e le associazioni di tasti opzionali), utilizzando `source <(sk --shell \<shell> \[--shell-bindings])`, vedi sotto per i dettagli

# Utilizzo

Skim può essere utilizzato sia come filtro generale (simile a `grep`) sia come
interfaccia interattiva per eseguire comandi.

## Come plugin Vim (su neovim, dai un'occhiata a [fzf-lua](https://github.com/ibhagwan/fzf-lua) con il profilo skim)

Tramite vim-plug (consigliato):

Installa skim, poi:```vim
Plug 'skim-rs/skim'

Quest'ultimo comando ti consente di selezionare file con estensione ".rs" e apre
le tue selezioni in Vim - un grande risparmio di tempo per gli sviluppatori!

## Come Interfaccia Interattiva

`skim` può invocare altri comandi dinamicamente. Normalmente vorresti
integrarlo con [grep](https://www.gnu.org/software/grep/),
[ack](https://github.com/petdance/ack2),
[ag](https://github.com/ggreer/the_silver_searcher), o
[rg](https://github.com/BurntSushi/ripgrep) per cercare contenuti in una
directory di progetto:```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}'

#### Opzione 2: Salvataggio in un file da caricare automaticamente all'avvio della 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

Puoi passare alla modalità `regex` dinamicamente premendo `Ctrl-R` (Rotate Mode).

## exit code

| Exit Code | Significato                        |
|-----------|------------------------------------|
| 0         | Uscita normale                     |
| 1         | Nessuna corrispondenza trovata     |
| 130       | Interrotto da Ctrl-C/Ctrl-G/ESC/ecc... |

# Strumenti compatibili con `skim`

Questi strumenti sono o mirano a essere compatibili con `skim`:

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

Un plugin per [neovim](https://neovim.io) che consente di usare fzf e skim per navigare nel tuo codice.

Installalo con il tuo gestore di pacchetti, seguendo il README. Ad esempio, con `lazy.nvim`:```lua
{
  "ibhagwan/fzf-lua",
  -- enable `sk` support instead of the default `fzf`
  opts = {'skim'}
}

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

Un modulo caricabile di `sqlite` che abilita una funzione `skim_score` nelle
query SQL.

# Personalizzazione

La documentazione qui è solo un'anteprima, consulta la pagina man (`man sk`) per un
elenco completo delle opzioni.

## Keymap

Specifica i binding con coppie separate da virgola (senza spazi). Ad esempio:```sh
sk --bind 'alt-a:select-all,alt-d:deselect-all'

Skim rispetta anche la variabile d'ambiente `NO_COLOR`. Impostala a qualsiasi valore e `sk` (e molte altre applicazioni da terminale) disabiliterà ogni output colorato. Consulta [no-color.org](https://no-color.org/) per maggiori dettagli.

### Schemi di Colore di Base Disponibili

Skim include diversi schemi di colore integrati che puoi usare come punto di partenza:```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)

I colori possono essere specificati in diversi modi:

- Colori ANSI (0-255): `sk --color=fg:232,bg:255`
- Valori esadecimali RGB: `sk --color=fg:#FF0000` (testo rosso)

### Opzioni di Personalizzazione Colore Disponibili

I seguenti elementi dell'interfaccia possono essere personalizzati:

| Elemento            | Descrizione                                 | Esempio                        |
|--------------------|---------------------------------------------|--------------------------------|
| `fg`               | Colore del testo normale in primo piano     | `--color=fg:232`               |
| `bg`               | Colore dello sfondo del testo normale       | `--color=bg:255`               |
| `matched`          | Testo corrispondente nei risultati di ricerca | `--color=matched:108`          |
| `matched_bg`       | Sfondo del testo corrispondente             | `--color=matched_bg:0`         |
| `current`          | Colore del testo della riga corrente        | `--color=current:254`          |
| `current_bg`       | Colore dello sfondo della riga corrente     | `--color=current_bg:236`       |
| `current_match`    | Testo corrispondente nella riga corrente    | `--color=current_match:151`    |
| `current_match_bg` | Sfondo del testo corrispondente nella riga corrente | `--color=current_match_bg:236` |
| `spinner`          | Colore dell'indicatore di avanzamento       | `--color=spinner:148`          |
| `info`             | Colore della riga informativa               | `--color=info:144`             |
| `prompt`           | Colore del prompt                           | `--color=prompt:110`           |
| `cursor`           | Colore del cursore                          | `--color=cursor:161`           |
| `selected`         | Colore del marcatore dell'elemento selezionato | `--color=selected:168`         |
| `header`           | Colore del testo dell'intestazione          | `--color=header:109`           |
| `border`           | Colore del bordo per anteprima/layout       | `--color=border:59`            |

### Esempi```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

### Come funziona?

![Come funziona la modalità interattiva di Skim](https://assets.kitploit.com/production/public/readmes/54416/5895df8cd6dbe8dfe20cafd1bf0b23fd690191710c00f811e110aba228b32a35/a7b995846d08eb2aa7f351371b38a9a35261eb393632363f62c6a67785f4038e-display-v1.webp)

- Skim accetta due tipi di sorgenti: output di comandi o input tramite pipe
- Skim ha due tipi di prompt: un prompt di query per specificare il pattern di ricerca e un
    prompt di comando per specificare gli "argomenti" del comando
- `-c` viene usato per specificare il comando da eseguire e il default è `SKIM_DEFAULT_COMMAND`
- `-i` dice a skim di aprire il prompt di comando all'avvio, che mostrerà `c>` di default.

Per restringere ulteriormente i risultati restituiti dal comando, premi
`Ctrl-Q` per attivare la modalità interattiva.

## Esecuzione di programmi esterni

Puoi configurare le scorciatoie da tastiera per avviare processi esterni senza uscire da 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'

(Nota che [preview.sh](https://github.com/junegunn/fzf.vim/blob/master/bin/preview.sh) è uno script per stampare il contesto dato filename:righe:colonne)

Ottieni risultati come questo:

![anteprima demo](https://assets.kitploit.com/production/public/readmes/54416/b89dd1e40297ffc3fa4684c4a6d5dc9506c0eafdb881d4cea079ff843f1a271a/84156872f39354a97241078491506fee9f9962eda6628161f94f6f36ec2c79f9-display-v1.webp)

### Come funziona?

Se il comando di anteprima viene fornito tramite l'opzione `--preview`, skim sostituirà
`{}` con la riga attualmente evidenziata racchiusa tra virgolette singole, chiamerà il
comando per ottenere l'output e stamperà l'output nella finestra di anteprima.

A volte non hai bisogno dell'intera riga per invocare il comando. In questo caso
puoi usare `{}`, `{1..}`, `{..3}` o `{1..5}` per selezionare i campi. La
sintassi è spiegata nella sezione [Supporto campi](#filds-support).

Infine, potresti voler configurare la posizione della finestra di anteprima con `--preview-window`:
- `--preview-window up:30%` per posizionare la finestra in alto con un'altezza
    pari al 30% dell'altezza totale di skim.
- `--preview-window left:10:wrap` per specificare che `wrap` consente alla finestra
    di anteprima di andare a capo nell'output del comando di anteprima.
- `--preview-window wrap:hidden` per nascondere la finestra di anteprima all'avvio; in seguito
    può essere mostrata tramite l'azione `toggle-preview`.

## Supporto campi

Normalmente solo gli utenti di plugin devono comprendere questa parte.

Ad esempio, hai la sorgente dati con il formato:```sh
<filename>:<line number>:<column number>

_Nota sulle funzionalità_:
    - la funzionalità `cli` è necessaria per usare skim come cli, *non* dovrebbe essere necessaria quando lo si usa come libreria.

### Utilizzo di base

Poi prova a eseguire questo semplice esempio:```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());
    }
}

Puoi inserirlo nel tuo `.bashrc` o `.zshrc` se vuoi che sia il comportamento predefinito.

## Alcuni file non vengono mostrati nel plugin Vim

Se usi il plugin Vim ed esegui il comando `:SK`, potresti notare che alcuni
dei tuoi file non vengono mostrati.

Come descritto in [#3](https://github.com/skim-rs/skim/issues/3), nel plugin
Vim, `SKIM_DEFAULT_COMMAND` è impostato al comando per impostazione predefinita:```vim
let $SKIM_DEFAULT_COMMAND = "git ls-tree -r --name-only HEAD || rg --files || ag -l -g \"\" || find ."

Dentro della VM, la root del progetto è montata su `C:\vagrant`:```powershell
cd C:\vagrant
cargo build
cargo test

# Risoluzione dei problemi

Per capire cosa sta succedendo, puoi impostare la variabile d'ambiente `SKIM_LOG` o il flag `--log-level` su `debug` o addirittura `trace`, e impostare la variabile d'ambiente `SKIM_LOG_FILE` o il flag `--log-file` su un percorso. Puoi quindi leggere questi log durante o dopo l'esecuzione per comprendere meglio cosa sta accadendo. Non esitare ad aggiungere questi log a un issue se hai bisogno di aiuto.

## Problemi di mancanza di avanzamento riga con nix, FreeBSD, termux

Se riscontri problemi di visualizzazione come:```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

# Benchmark

## Benchmark interattivo (`cli`)

Il benchmark `cli` confronta skim (o qualsiasi binario compatibile) con altre versioni o con fzf eseguendo l'interfaccia interattiva all'interno di una sessione tmux e interrogando la riga di stato finché il conteggio delle corrispondenze non si stabilizza. Non è affatto una misurazione precisa o infallibile, ma ha il vantaggio aggiuntivo di confrontarsi con `fzf` e di fornire metriche sulle risorse (picco di RSS e 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