## Manualmente

Se aplica cualquiera de las siguientes opciones:

- Usando el script de instalación:
    ```sh
    # ¡Comprueba siempre el contenido del script antes de ejecutarlo!
    $ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/skim-rs/skim/releases/latest/download/skim-installer.sh | sh
    ```
- Usando el binario: Simplemente [descarga el ejecutable sk](https://github.com/skim-rs/skim/releases) directamente.
- Instalar desde [crates.io](https://crates.io/): `cargo install skim`
- Compilar manualmente:
    ```sh
    $ git clone --depth 1 [email protected]:skim-rs/skim.git ~/.skim
    $ cd ~/.skim
    $ cargo build --release
    $ # Añade el ejecutable resultante `target/release/sk` a tu PATH
    ```

Entonces tendrás acceso a:

- La página man, que puedes escribir en la ruta correcta o ejecutar `man --local-file <(sk --man)`
- Las completaciones de shell (y atajos de teclado opcionales), usando `source <(sk --shell \<shell> \[--shell-bindings])`, consulta los detalles a continuación

# Uso

Skim se puede usar como un filtro general (similar a `grep`) o como una
interfaz interactiva para ejecutar comandos.

## Como plugin de Vim (en neovim, consulta [fzf-lua](https://github.com/ibhagwan/fzf-lua) con el perfil de skim)

Mediante vim-plug (recomendado):

Instala skim, luego:```vim
Plug 'skim-rs/skim'

Este último comando te permite seleccionar archivos con la extensión ".rs" y abre
tus selecciones en Vim: ¡un gran ahorro de tiempo para desarrolladores!

## Como Interfaz Interactiva

`skim` puede invocar otros comandos dinámicamente. Normalmente querrías
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) para buscar contenidos en un
directorio de proyecto:```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}'

#### Opción 2: Guardar en un archivo para que se cargue automáticamente al iniciar el 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

Puedes cambiar al modo `regex` dinámicamente presionando `Ctrl-R` (Rotar Modo).

## código de salida

| Código de salida | Significado                          |
|-----------|--------------------------------------|
| 0         | Salida normal                        |
| 1         | No se encontró coincidencia          |
| 130       | Interrumpido por Ctrl-C/Ctrl-G/ESC/etc... |

# Herramientas compatibles con `skim`

Estas herramientas son o pretenden ser compatibles con `skim`:

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

Un complemento de [neovim](https://neovim.io) que permite usar fzf y skim para navegar por tu código.

Instálalo con tu gestor de paquetes, siguiendo el README. Por ejemplo, con `lazy.nvim`:```lua
{
  "ibhagwan/fzf-lua",
  -- enable `sk` support instead of the default `fzf`
  opts = {'skim'}
}

## [extensión sqlite](https://github.com/tzachar/sqlite_skim)

Un módulo cargable de `sqlite` que habilita una función `skim_score` en
consultas SQL.

# Personalización

La documentación aquí es solo una vista previa; consulta la página man (`man sk`) para obtener una
lista completa de opciones.

## Mapa de teclas

Especifica los enlaces con pares separados por comas (sin espacios permitidos). Por ejemplo:```sh
sk --bind 'alt-a:select-all,alt-d:deselect-all'

Skim también respeta la variable de entorno `NO_COLOR`. Establézcala a cualquier valor y `sk` (y muchas otras aplicaciones de terminal) desactivará toda la salida en color. Consulte [no-color.org](https://no-color.org/) para más detalles.

### Esquemas de Color Base Disponibles

Skim incluye varios esquemas de color integrados que puede usar como punto de partida:```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)

Los colores se pueden especificar de varias formas:

- Colores ANSI (0-255): `sk --color=fg:232,bg:255`
- Valores hexadecimales RGB: `sk --color=fg:#FF0000` (texto rojo)

### Opciones de Personalización de Color Disponibles

Los siguientes elementos de la interfaz se pueden personalizar:

| Elemento            | Descripción                                 | Ejemplo                        |
|--------------------|---------------------------------------------|--------------------------------|
| `fg`               | Color de primer plano del texto normal      | `--color=fg:232`               |
| `bg`               | Color de fondo del texto normal             | `--color=bg:255`               |
| `matched`          | Texto coincidente en los resultados de búsqueda | `--color=matched:108`      |
| `matched_bg`       | Fondo del texto coincidente                 | `--color=matched_bg:0`         |
| `current`          | Color de primer plano de la línea actual    | `--color=current:254`          |
| `current_bg`       | Color de fondo de la línea actual           | `--color=current_bg:236`       |
| `current_match`    | Texto coincidente en la línea actual        | `--color=current_match:151`    |
| `current_match_bg` | Fondo del texto coincidente en la línea actual | `--color=current_match_bg:236` |
| `spinner`          | Color del indicador de progreso             | `--color=spinner:148`          |
| `info`             | Color de la línea de información            | `--color=info:144`             |
| `prompt`           | Color del prompt                            | `--color=prompt:110`           |
| `cursor`           | Color del cursor                            | `--color=cursor:161`           |
| `selected`         | Color del marcador del elemento seleccionado | `--color=selected:168`        |
| `header`           | Color del texto de cabecera                 | `--color=header:109`           |
| `border`           | Color del borde para vista previa/diseño    | `--color=border:59`            |

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

### ¿Cómo funciona?

![Cómo funciona el modo interactivo de Skim](https://assets.kitploit.com/production/public/readmes/54416/5895df8cd6dbe8dfe20cafd1bf0b23fd690191710c00f811e110aba228b32a35/a7b995846d08eb2aa7f351371b38a9a35261eb393632363f62c6a67785f4038e-display-v1.webp)

- Skim acepta dos tipos de fuentes: salida de comandos o entrada canalizada (piped input)
- Skim tiene dos tipos de indicadores: un indicador de consulta para especificar el patrón de búsqueda y un
    indicador de comando para especificar los "argumentos" del comando
- `-c` se usa para especificar el comando a ejecutar y por defecto usa `SKIM_DEFAULT_COMMAND`
- `-i` le indica a skim que abra el indicador de comando al iniciar, que mostrará `c>` por defecto.

Para reducir aún más los resultados devueltos por el comando, presione
`Ctrl-Q` para alternar el modo interactivo.

## Ejecutar programas externos

Puede configurar enlaces de teclas para iniciar procesos externos sin salir de 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'

(Tenga en cuenta que [preview.sh](https://github.com/junegunn/fzf.vim/blob/master/bin/preview.sh) es un script para imprimir el contexto dado nombre_de_archivo:líneas:columnas)

Obtienes cosas como esta:

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

### ¿Cómo funciona?

Si el comando de vista previa se proporciona mediante la opción `--preview`, skim reemplazará
`{}` con la línea resaltada actual rodeada de comillas simples, llamará al
comando para obtener la salida e imprimirá la salida en la ventana de vista previa.

A veces no necesitas la línea completa para invocar el comando. En este caso
puedes usar `{}`, `{1..}`, `{..3}` o `{1..5}` para seleccionar los campos. La
sintaxis se explica en la sección [Soporte de campos](#filds-support).

Por último, es posible que quieras configurar la posición de la ventana de vista previa con `--preview-window`:
- `--preview-window up:30%` para colocar la ventana en la posición superior con una altura
    del 30% de la altura total de skim.
- `--preview-window left:10:wrap` para especificar que `wrap` permite que la ventana de vista previa
    ajuste la salida del comando de vista previa.
- `--preview-window wrap:hidden` para ocultar la ventana de vista previa al inicio; más tarde
    se puede mostrar con la acción `toggle-preview`.

## Soporte de campos

Normalmente solo los usuarios de complementos necesitan entender esto.

Por ejemplo, tienes la fuente de datos con el formato:```sh
<filename>:<line number>:<column number>

_Nota sobre las características_:
    - la característica `cli` es necesaria para usar skim como cli, *no debería* ser necesaria al usarlo como biblioteca.

### Uso básico

Luego intenta ejecutar este sencillo ejemplo:```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());
    }
}

Puedes ponerlo en tu `.bashrc` o `.zshrc` si quieres que sea el predeterminado.

## Algunos archivos no se muestran en el plugin de Vim

Si usas el plugin de Vim y ejecutas el comando `:SK`, puede que algunos
de tus archivos no se muestren.

Como se describe en [#3](https://github.com/skim-rs/skim/issues/3), en el
plugin de Vim, `SKIM_DEFAULT_COMMAND` se establece al comando por defecto:```vim
let $SKIM_DEFAULT_COMMAND = "git ls-tree -r --name-only HEAD || rg --files || ag -l -g \"\" || find ."

Dentro de la VM, la raíz del proyecto está montada en `C:\vagrant`:```powershell
cd C:\vagrant
cargo build
cargo test

# Solución de problemas

Para diagnosticar qué está sucediendo, puedes establecer la variable de entorno `SKIM_LOG` o la bandera `--log-level` en `debug` o incluso `trace`, y establecer la variable de entorno `SKIM_LOG_FILE` o la bandera `--log-file` en una ruta. Luego puedes leer esos registros durante o después de la ejecución para comprender mejor qué está ocurriendo. No dudes en añadir esos registros a un issue si necesitas ayuda.

## Problemas de salto de línea con nix, FreeBSD, termux

Si encuentras problemas de visualización como:```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 interactivo (`cli`)

El benchmark `cli` compara skim (o cualquier binario compatible) con otras versiones o con fzf ejecutando la interfaz interactiva dentro de una sesión de tmux y consultando la línea de estado hasta que el recuento de coincidencias se estabiliza. De ninguna manera es una medición precisa o infalible, pero tiene el beneficio adicional de comparar contra `fzf` y de proporcionar métricas de recursos (RSS máximo y 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