## Manualmente

Qualquer uma das seguintes opções se aplica:

- Usando o script de instalação:
    ```sh
    # Sempre verifique o conteúdo do script antes de executá-lo!
    $ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/skim-rs/skim/releases/latest/download/skim-installer.sh | sh
    ```
- Usando o binário: Basta [baixar o executável sk](https://github.com/skim-rs/skim/releases) diretamente.
- Instalar a partir do [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
    $ # Adicione o executável `target/release/sk` resultante ao seu PATH
    ```

Você terá então acesso a:

- A página de manual, que você pode gravar no caminho correto ou executar `man --local-file <(sk --man)`
- As completions de shell (e keybinds opcionais), usando `source <(sk --shell \<shell> \[--shell-bindings])`, veja abaixo para detalhes

# Uso

O Skim pode ser usado tanto como um filtro geral (semelhante ao `grep`) quanto como uma
interface interativa para executar comandos.

## Como plugin do Vim (no neovim, confira [fzf-lua](https://github.com/ibhagwan/fzf-lua) com o perfil skim)

Via vim-plug (recomendado):

Instale o skim, depois:```vim
Plug 'skim-rs/skim'

Este último comando permite selecionar arquivos com a extensão ".rs" e abre
suas seleções no Vim - uma grande economia de tempo para desenvolvedores!

## Como Interface Interativa

O `skim` pode invocar outros comandos dinamicamente. Normalmente, você vai querer
integrá-lo com [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) para pesquisar conteúdos em um
diretório de projeto:```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}'

#### Opção 2: Guardar num ficheiro para ser carregado automaticamente no arranque do 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

Pode alternar para o modo `regex` dinamicamente ao pressionar `Ctrl-R` (Modo Rotacionar).

## código de saída

| Código de Saída | Significado                        |
|-----------------|------------------------------------|
| 0               | Saiu normalmente                   |
| 1               | Nenhuma correspondência encontrada |
| 130             | Interrompido por Ctrl-C/Ctrl-G/ESC/etc... |

# Ferramentas compatíveis com `skim`

Estas ferramentas são ou pretendem ser compatíveis com `skim`:

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

Um plugin para [neovim](https://neovim.io) que permite usar fzf e skim para navegar pelo seu código.

Instale-o com o seu gestor de pacotes, seguindo o README. Por exemplo, com `lazy.nvim`:```lua
{
  "ibhagwan/fzf-lua",
  -- enable `sk` support instead of the default `fzf`
  opts = {'skim'}
}

## [extensão sqlite](https://github.com/tzachar/sqlite_skim)

Um módulo carregável do `sqlite` que habilita uma função `skim_score` em
consultas SQL.

# Personalização

A documentação aqui é apenas uma prévia; consulte a página de manual (`man sk`) para uma lista
completa de opções.

## Mapa de teclas

Especifique os atalhos com pares separados por vírgula (sem espaços permitidos). Por exemplo:```sh
sk --bind 'alt-a:select-all,alt-d:deselect-all'

O Skim também respeita a variável de ambiente `NO_COLOR`. Defina-a com qualquer valor e o `sk` (e muitos outros aplicativos de terminal) desativará toda a saída colorida. Consulte [no-color.org](https://no-color.org/) para mais detalhes.

### Esquemas de Cores Base Disponíveis

O Skim vem com vários esquemas de cores integrados que você pode usar como ponto 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)

As cores podem ser especificadas de várias formas:

- Cores ANSI (0-255): `sk --color=fg:232,bg:255`
- Valores hexadecimais RGB: `sk --color=fg:#FF0000` (texto vermelho)

### Opções de Personalização de Cores Disponíveis

Os seguintes elementos da interface podem ser personalizados:

| Elemento            | Descrição                                 | Exemplo                        |
|--------------------|---------------------------------------------|--------------------------------|
| `fg`               | Cor de primeiro plano do texto normal                | `--color=fg:232`               |
| `bg`               | Cor de fundo do texto normal                | `--color=bg:255`               |
| `matched`          | Texto correspondente nos resultados da pesquisa              | `--color=matched:108`          |
| `matched_bg`       | Fundo do texto correspondente                  | `--color=matched_bg:0`         |
| `current`          | Cor de primeiro plano da linha atual               | `--color=current:254`          |
| `current_bg`       | Cor de fundo da linha atual               | `--color=current_bg:236`       |
| `current_match`    | Texto correspondente na linha atual                | `--color=current_match:151`    |
| `current_match_bg` | Fundo do texto correspondente na linha atual  | `--color=current_match_bg:236` |
| `spinner`          | Cor do indicador de progresso                    | `--color=spinner:148`          |
| `info`             | Cor da linha de informações                      | `--color=info:144`             |
| `prompt`           | Cor do prompt                                | `--color=prompt:110`           |
| `cursor`           | Cor do cursor                                | `--color=cursor:161`           |
| `selected`         | Cor do marcador do item selecionado                  | `--color=selected:168`         |
| `header`           | Cor do texto do cabeçalho                           | `--color=header:109`           |
| `border`           | Cor da borda para pré-visualização/layout             | `--color=border:59`            |

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

### Como funciona?

![Como funciona o modo interativo do Skim](https://assets.kitploit.com/production/public/readmes/54416/5895df8cd6dbe8dfe20cafd1bf0b23fd690191710c00f811e110aba228b32a35/a7b995846d08eb2aa7f351371b38a9a35261eb393632363f62c6a67785f4038e-display-v1.webp)

- O Skim aceita dois tipos de fontes: saída de comandos ou entrada via pipe
- O Skim tem dois tipos de prompts: um prompt de consulta para especificar o padrão de busca e um
    prompt de comando para especificar os "argumentos" do comando
- `-c` é usado para especificar o comando a ser executado e tem como padrão `SKIM_DEFAULT_COMMAND`
- `-i` informa ao skim para abrir o prompt de comando na inicialização, que mostrará `c>` por padrão.

Para refinar ainda mais os resultados retornados pelo comando, pressione
`Ctrl-Q` para alternar o modo interativo.

## Executando programas externos

Você pode configurar atalhos de teclado para iniciar processos externos sem sair do 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'

(Note que [preview.sh](https://github.com/junegunn/fzf.vim/blob/master/bin/preview.sh) é um script para imprimir o contexto dado filename:lines:columns)

Você obtém coisas assim:

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

### Como funciona?

Se o comando de preview for fornecido pela opção `--preview`, o skim substituirá
o `{}` pela linha atualmente destacada entre aspas simples, chamará o
comando para obter a saída e imprimirá a saída na janela de preview.

Às vezes você não precisa da linha inteira para invocar o comando. Nesse caso,
você pode usar `{}`, `{1..}`, `{..3}` ou `{1..5}` para selecionar os campos. A
sintaxe é explicada na seção [Suporte a campos](#filds-support).

Por fim, você pode querer configurar a posição da janela de preview com `--preview-window`:
- `--preview-window up:30%` para colocar a janela na posição superior com altura
    30% da altura total do skim.
- `--preview-window left:10:wrap` para especificar que o `wrap` permite que a janela
    de preview quebre a saída do comando de preview.
- `--preview-window wrap:hidden` para ocultar a janela de preview na inicialização; depois,
    ela pode ser exibida pela ação `toggle-preview`.

## Suporte a campos

Normalmente, apenas usuários de plugins precisam entender isso.

Por exemplo, você tem a fonte de dados com o formato:```sh
<filename>:<line number>:<column number>

_Nota sobre funcionalidades_:
    - a funcionalidade `cli` é necessária para usar o skim como cli, ela *não* deve ser necessária ao usá-lo como biblioteca.

### Uso básico

Em seguida, tente executar este exemplo simples:```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());
    }
}

Podes colocá-lo no teu `.bashrc` ou `.zshrc` se quiseres que seja o padrão.

## Alguns ficheiros não são mostrados no plugin do Vim

Se usares o plugin do Vim e executares o comando `:SK`, podes descobrir que alguns
dos teus ficheiros não são mostrados.

Conforme descrito em [#3](https://github.com/skim-rs/skim/issues/3), no plugin
do Vim, `SKIM_DEFAULT_COMMAND` é definido para o comando por predefinição:```vim
let $SKIM_DEFAULT_COMMAND = "git ls-tree -r --name-only HEAD || rg --files || ag -l -g \"\" || find ."

Dentro da VM, a raiz do projeto está montada em `C:\vagrant`:```powershell
cd C:\vagrant
cargo build
cargo test

# Resolução de Problemas

Para diagnosticar o que está acontecendo, você pode definir a variável de ambiente `SKIM_LOG` ou a flag `--log-level` para `debug` ou até mesmo `trace`, e definir a variável de ambiente `SKIM_LOG_FILE` ou a flag `--log-file` para um caminho. Você pode então ler esses logs durante ou após a execução para entender melhor o que está acontecendo. Não hesite em adicionar esses logs a uma issue se precisar de ajuda.

## Problemas de quebra de linha com nix, FreeBSD, termux

Se você encontrar problemas de exibição 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 interativo (`cli`)

O benchmark `cli` avalia o skim (ou qualquer binário compatível) em comparação com outras versões ou com o fzf, executando a interface interativa dentro de uma sessão tmux e consultando a linha de status até que a contagem de correspondências se estabilize. Esta não é, de forma alguma, uma medição precisa ou infalível, mas tem o benefício adicional de comparar com o `fzf` e de fornecer métricas de recursos (pico de 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