"Segnalibri" per bash

Navigare su più livelli di directory nidificate è spesso una seccatura. Su Firefox, è facile perché hanno segnalibri. Quindi quello che vorrei fare per aggiungere un segnalibro a un file è digitare:

$ go --add classes "repo/www/public/util/classes"

Quindi, per andare in questa directory, digitare:

$ go classes

In precedenza ho usato collegamenti simbolici, per ottenere qualcosa di simile, ma non voglio ingombrare la mia directory home. Ci sono molte altre funzionalità che potrebbero rivelarsi utili. Ad esempio, vorrei poter iniziare a digitare go cle quindi premere tab per completare automaticamente. A volte ho estratto più copie di un repository e quindi sarebbe utile per il programma permettermi di creare più contesti e di impostare il segnalibro relativo alla directory di base del contesto.

Quindi, prima di iniziare a mettere insieme il mio set di script, c'è già qualcosa del genere?

Stavo cercando uno strumento di bookmarking della shell da troppo tempo e non sono soddisfatto di nessuna delle soluzioni che ho trovato.

Tuttavia, alla fine mi sono imbattuto in un grande strumento universale: il fuzzy finder della riga di comando .

Ti consente principalmente di "trovare fuzzy-find" (controlla la ricca animazione gif tramite il link sopra), ma ti permette anche di fornire dati di testo arbitrari e filtrarli. Quindi, l'idea di scorciatoie è semplice: tutto ciò che serve è mantenere un file con percorsi (che sono scorciatoie) e filtrare fuzzy questo file. Ecco come appare: digitiamo cdgcommand (da "cd global", se lo desideri), otteniamo un elenco dei nostri segnalibri, selezioniamo quello necessario in pochi tasti e premiamo Invio. La directory di lavoro viene modificata nell'elemento selezionato:

È estremamente veloce e conveniente: di solito scrivo solo 3-4 lettere dell'articolo necessario e tutti gli altri sono già filtrati. Inoltre, ovviamente possiamo spostarci nell'elenco con i tasti freccia o con Ctrl+j/ Ctrl+k.

L'articolo dettagliato su questa soluzione di scorciatoie / segnalibri è qui: scorciatoie fuzzy per la tua shell .

Penso che tu stia cercando qualcosa come l' autojump . Devi fare un po 'di cd per sviluppare un insieme di "pesi chiave" che si correlano con la quantità di tempo trascorso in una determinata directory. Quindi, supponendo che tu abbia trascorso molto tempo in quella directory delle "classi", puoi saltare direttamente digitando

j cl

È possibile visualizzare i "pesi chiave" con

jumpstat

Come dice Saeedn, gli alias sono un buon meccanismo. La shell bash dispone anche di un meccanismo incorporato per saltare direttamente a una posizione: CDPATH. Impostalo come PATH, ma viene utilizzato cdinvece di cercare programmi.

$ CDPATH=:~/repo/www/public/util
$ cd classes
/home/casebash/repo/www/public/util/classes

Dalla manpage:

   CDPATH The search path for the cd command.  This is  a  colon-separated
          list  of  directories  in  which the shell looks for destination
          directories specified by the cd  command.   A  sample  value  is
          ".:~:/usr".

Io stesso, l'ho combinato con una directory che ha collegamenti simbolici a dove vorrei andare:

$ mkdir ~/cdshortcut
$ ln -s ~/repo/www/public/util/classes ~/cdshortcut/classes
$ CDPATH=:~/cdshortcut
/home/casebash/cdshortcut/classes

Ciò ha lo svantaggio che la directory non sembra essere corretta, ma che può essere corretta usando cd -Po impostando set -P.

È possibile combinare le funzionalità di ricerca della cronologia e della cronologia esistenti di Bash. Premere Ctrl-Rper iniziare la ricerca inversa incrementale, quindi iniziare a digitare la parte del percorso che molto probabilmente sarà unica.

Puoi continuare a digitare lettere fino a quando non torni indietro al cdcomando più recente che coinvolge quella directory, oppure puoi premere di Ctrl-Rnuovo per tornare indietro nella cronologia al comando più recente successivo corrispondente a quello che hai digitato finora.

Lo faccio sempre.

In realtà, faccio un ulteriore passo avanti. Una volta che inizio a scoprire sequenze di comandi che vale la pena tenere nella storia ma non vale la pena impegnarmi in uno script di shell, inizio a concatenarle con &&e ;combinatori in modo da poter cercare indietro una sottostringa di quell'unico comando lungo, premere Entered eseguire l'intera sequenza in una volta.

Ad esempio, ecco come costruisco ed eseguo uno dei miei programmi durante lo sviluppo:

$ ( cd .. ; make install ) && ./start_my_program

Lo faccio dalla directory di installazione, che si trova sotto la directory di origine di livello superiore. Avvolgendo cd, costruendo e installando la parte in una sotto-shell, mi assicuro che, qualunque cosa accada durante questo processo, finisco di nuovo nella mia normale shell senza che nulla sia cambiato. Solo se ciò ha esito positivo (&&), avvio il programma creato e installato. Posso trovarlo nella mia storia con solo un Ctrl-Rmomento sta, che essendo tutto ciò che di solito ho bisogno per trovare in modo univoco questa sequenza di comandi.

Un altro esempio di come lo uso è la sequenza che va alla creazione di RPM per questo stesso programma. La maggior parte del lavoro noioso è negli script di shell, ma normalmente ci sono ancora alcuni comandi che dovrei digitare per fare tutto il lavoro di costruzione e distribuzione degli RPM costruiti, che ora raramente devo riscrivere, perché Bash mantiene nella storia per me.

Combina tutto questo con export HISTSIZE=bignume shopt histappende hai appena costruito una memoria di comando di elefanti.

Un'altra soluzione che ho codificato una volta è nella mia risposta a un'altra domanda qui . Potrebbe dover essere personalizzato per i tuoi scopi e gestisce solo i cdcomandi, mentre l'opzione di ricerca della cronologia funziona ovunque e per ogni comando.

Io stesso uso aliasper abbreviare lunghi percorsi che visito spesso. Puoi mettere il tuo set di aliases nel tuo bashrc, così bash potrebbe ricordarseli ogni volta che accedi. E fortunatamente bash aggiunge alias al completamento automatico.

Scriverei qualcosa del genere per il tuo caso: alias go-classes="cd ~/repo/www/public/util/classes"

Potresti cercare segni bash (su github).
Dal README:

Bashmarks è uno script di shell che ti consente di salvare e saltare alle directory di uso comune. Ora supporta il completamento della scheda.

Questo non è affatto completo né infallibile, solo una bozza per cominciare. Aggiungendo quanto segue nel tuo ~/.bashrcavrai tre comandi per aggiungere i segnalibri di directory di eliminazione ed elenco (che sono basati su alias di shell, quindi anche tu potresti ottenere il completamento automatico).

BMFILE=~/.bash.bookmarks
[ -f "$BMFILE" ] && . "$BMFILE"

bmadd() {
    local abm
    if [[ $# = 0 ]]; then
        bm=$(basename $(pwd))
    else
        bm=$1
    fi

    abm="alias $bm='cd \"$(pwd)\"'"

    if grep -q " $bm=" "$BMFILE"; then
        echo "Overwriting existing bookmark $bm"
        bmdel "$bm"
    fi
    echo "$abm" >> "$BMFILE"
    eval "$abm"
    #source "$BMFILE"
}

bmdel() {
    local bms
    if [[ $# = 0 ]]; then
        bm=$(basename $(pwd))
    else
        bm=$1
    fi

    #sed -i.bak "/ $bm=/d" "$BMFILE"
    bms=$(grep -v " $bm=" "$BMFILE")
    echo "$bms" > "$BMFILE"
    unalias "$bm" 2> /dev/null
}

bmlist() {
    sed 's/alias \(.*\)=.cd "\(.*\)".$/\1\t\2/' "$BMFILE" | sort
}

L'utilizzo è piuttosto semplice. bmaddcon un argomento aggiunge un alias che prende il nome dall'argomento. Questo alias crea semplicemente un cd nella directory in cui è stato impostato. Senza un argomento utilizza l'attuale dirname come nome alias. Allo stesso modo, bmdelelimina un alias se esiste ed bmlistelenca i segnalibri correnti.

per esempio

u@h:~ $ cd /usr/share/doc
u@h:/usr/share/doc $ bmadd
u@h:/usr/share/doc $ cd /usr/local/share/
u@h:/usr/local/share $ bmadd lshare
u@h:/usr/local/share $ cd
u@h:~ $ bmlist
doc     /usr/share/doc
lshare  /usr/local/share
u@h:~ $ doc
u@h:/usr/share/doc $ bmdel lshare
u@h:/usr/share/doc $ bmlist
doc     /usr/share/doc
u@h:/usr/share/doc $

Qualche tempo fa mi sono imbattuto nella stessa necessità e ho deciso di mettere insieme un paio di script per aiutarmi a contrassegnare percorsi assoluti / relativi e mapparli su nomi più brevi che posso ricordare facilmente.

Lo script è molto facile da usare e creerà semplicemente una funzione con il nome breve che fornisci come alias alla directory in cui vuoi saltare. Tutto quello che devi fare è semplicemente digitare quel nome breve e ti porterà alla directory dei segnalibri.

Ecco un link alla fonte dello script del segnalibro. A proposito, l'ho chiamato The Bookmarker.

uso

Una volta installato è piuttosto banale da usare.

Per contrassegnare una directory:

$ mark /this/is/a/very/very/looooong/path mydir

Per navigare verso una directory contrassegnata:

$ mydir

Per vedere cosa è stato contrassegnato:

$ marks
bin     -> /Users/khafaji/bin
eBooks  -> /Users/khafaji/eBooks

Per eliminare una directory contrassegnata:

$ umark myDir

Per ulteriori esempi, istruzioni di installazione ecc. Consultare la documentazione molto dettagliata .

cdargs è lo strumento migliore per il bookmarking della directory.

Per esempi di utilizzo, vedere i segnalibri per il video di comando cd su YouTube.

Esempio di utilizzo

cdargsè una GUI di ncurses in modo da poter navigare visivamente all'interno della shell. Una volta installato, lo si imposta in una determinata shell acquistando uno script di shell:

$ source /etc/profile.d/cdargs.sh

Questo abilita diverse funzioni che puoi quindi chiamare dalla tua shell.

Evoca la GUI:

$ cv

Risultato in questo tipo di una GUI:

   [.       ]  /home/saml/tst/88040
 0 [path0   ]  /home/saml/tst/88040/path0
 1 [path1   ]  /home/saml/tst/88040/path1
 2 [path2   ]  /home/saml/tst/88040/path2

È possibile utilizzare i tasti freccia per spostarsi su e giù per navigare nell'elenco. La freccia sinistra ( ←) sale di un livello nell'albero della directory, una freccia destra ( →) eseguirà il drill down in una directory.

marcatura delle directory:

Puoi utilizzare cla directory corrente che stai navigando oppure puoi aaggiungere la directory che stai evidenziando con il cursore.

modalità operative:

cdargsè un po 'come vi / vim in questo senso dove ha questa nozione di modalità . Ce ne sono 2, la navigazione (B) e l'elenco (L). Puoi vedere in quale modalità ti trovi attraverso il display nella parte inferiore della shell.

Modalità elenco:

L: /home/saml/tst/88038

Modalità di navigazione:

B: /home/saml/tst/88038

Puoi modificare la tua modalità premendo il tasto tab ( TAB).

Questa è solo la punta dell'iceberg, consultare la pagina man ( man cdargs) e anche la guida integrata per ulteriori informazioni.

Lo strumento migliore per questo è: wcd . Ho testato molti altri strumenti, e questo è usato esattamente nel modo in cui lo chiedi ed è migliore in molti sensi rispetto a tutte le soluzioni precedenti.

Le altre risposte sono grandi e specifiche. Un altro modo di vederlo è usare un processore macro per tastiera che può fare quasi tutto ciò che ti viene in mente.

Dai un'occhiata a AutoKey. Può sostituire frasi come la correzione automatica di un elaboratore di testi o la cronologia di bash e può anche eseguire uno script Python su un tasto di scelta rapida definito che può fare quasi tutto e anche inviare sequenze di tasti al dispositivo di immissione dei caratteri, proprio come se li digitassi.

L'unico "difetto" che ha (in relazione a questa domanda) è che ha bisogno di una GUI per eseguire in - gnome o kde. Le altre risposte non hanno questo requisito.

https://code.google.com/p/autokey/

C'è un'altra alternativa chiamata z .

Impara ad ogni cambio di directory:

$ cd /tmp/
$ pwd
/tmp
$ cd
$ pwd
/home/user

Quindi puoi passare a quella directory in seguito con la corrispondenza fuzzy:

$ z mp
$ pwd
/tmp

Apparix è un altro strumento che fa questo. Una delle sue utili funzionalità è che puoi passare direttamente alle sottodirectory del segno e completare la scheda in quelle sottodirectory.

Un'altra soluzione che, credo, è autojumped zè fasd.

Tiene traccia delle directory che visiti e z dir-namecambierà nella directory con il nome dir-nameche usi più frequentemente. Ha anche alcune funzionalità per i file utilizzati di frequente.

Puoi clonarlo da: https://github.com/clvv/fasd

L'installazione è semplice, clona, ​​esegui l'installazione e quindi modifica il tuo .bashrc(o .zshrcecc.).

Devi aggiungere un alias al tuo .bashrco .bash_profile.

## navigate to your home directory
$ cd ~
## list the contents of your home directory to see if you have `.bashrc` or `.bash_profile`
$ ls -a 
[`.bashrc` or `.bash_profile` should appear in the list]
## launch the text editor of your choice; I'll use vim here
## if no `~/.bashrc` or `~/.bash_profile`...
$ vim
## if, e.g., `~/.bash_profile` listed...
$ vim ~/.bash_profile

Ora, supponiamo che tu voglia una scorciatoia ~/Desktop/Coding/Projectsper invocare ciò che digiterai goto_Projs. È necessario aggiungere la seguente riga al file aperto nell'editor di testo:

alias goto_Projs='cd ~/Desktop/Coding/Projects'

Ora fai tutto ciò che il tuo editor di testo vuole che tu faccia per salvare ( /User/<yourusername>/o ~/ovviamente) e uscire, e quando il prompt della shell viene restituito vai

source ~/.bash_profile

Il tuo alias ora dovrebbe essere disponibile per invocare come descritto sopra.

Uso il metodo di aggiungere un commento alla fine del comando e quindi invocare ctrl Rper invertire la ricerca del commento. Questo ha i seguenti vantaggi:

• cerca un comando in linguaggio naturale
• cambia il commento in qualsiasi momento al volo e ottieni l'ultimo aggiornamento da ctrl R
• usa ctrl Re tabal volo per apportare piccole modifiche al comando stesso, rendendo così il commento una sorta di scorciatoia generica a una famiglia di comandi simili
• nessuna installazione, installazione o tenuta dei libri richiesta :-)