Eseguire un comando da un'altra directory in bash

Dì che lo sto facendo:

cd subdir
git init
cd ../

C'è un modo per farlo con un singolo comando, o forse due, anziché dover entrare e uscire da una directory per eseguire un comando lì?

(Non cerco una soluzione specifica per git; questo è solo un esempio.)

Questo è spesso il modo migliore:

( cd dir ; git init )

o

( cd dir && git init )

È piuttosto breve e facile da scrivere. Avvia una sotto-shell, quindi non è possibile modificare il proprio ambiente da quello, ma questo non sembra essere un problema qui.

Stavo cercando un modo per eseguire il comando git da un percorso e apportare modifiche al repository in un percorso diverso. Quindi ho finito con questa domanda qui.

Ma per le mie esigenze specifiche né la risposta accettata né nessuna delle altre ha aiutato.

Avevo bisogno di eseguire i comandi git utilizzando sudo -u USER /usr/bin/git(un altro utente che lo esegue). E come forse sapete, sudo non mi permette di eseguire il cdcomando, quindi non posso essere nella directory repository.

Quindi, sono andato alla pagina man di git . E tra le opzioni, ho visto --git-dir=<path>:

--git-dir =

Imposta il percorso per il repository. Questo può anche essere controllato impostando la variabile d'ambiente GIT_DIR. Può essere un percorso assoluto o relativo alla directory di lavoro corrente.

Quindi, se aiuta qualcuno, puoi comunque usare git da un percorso e apportare modifiche a un repository "lontano da te". Usa solo:

git --git-dir=/path/to/repository GIT_COMMAND

oppure, per eseguirlo come un altro utente, fai qualcosa del tipo:

echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir=/path/to/repository GIT_COMMAND

Anche dalla pagina man di git-init :

Se la variabile di ambiente $ GIT_DIR è impostata, specifica un percorso da utilizzare anziché ./.git per la base del repository.

Quindi, se si desidera avviare il repository nella normale cartella .git, sarà necessario specificarlo insieme --git-dirall'opzione. per esempio:

echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir=/path/to/repository/.git init

Dopo aver inizializzato il repository su /path/to/repo/.git, tutti gli altri comandi dovrebbero avere l'opzione --work-tree=<path>, come descritto nella pagina man di git:

--work-albero =

Imposta il percorso per l'albero di lavoro. Può essere un percorso assoluto o un percorso relativo alla directory di lavoro corrente. Questo può anche essere controllato impostando la variabile d'ambiente GIT_WORK_TREE e la variabile di configurazione core.worktree (vedi core.worktree in git-config (1) per una discussione più dettagliata).

Quindi, il comando giusto per eseguire git come un altro utente e inizializzare un nuovo repository è:

echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir=/path/to/repository/.git init
echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir='/path/to/repository/.git' --work-tree='/path/to/repository' add /path/to/repository/*
echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir='/path/to/repository/.git' --work-tree='/path/to/repository' commit -m 'MESSAGE'
echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir='/path/to/repository/.git' --work-tree='/path/to/repository' remote add origin user@domain.com:path
echo USER_PASSWORD | sudo -u USER_LOGIN -S /usr/bin/git --git-dir='/path/to/repository/.git' --work-tree='/path/to/repository' push -u origin master

Non esattamente quello che stai chiedendo (hai risposte reali sopra con la subshell) ma guarda pushdepopd

Hai alcune opzioni. Puoi raggruppare i comandi con &&o ;. Come questo:

cd subdir && git init && cd ..

o

cd subdir; git init; cd ..

La differenza tra questi è che nel primo esempio, se uno dei comandi fallisce, non eseguirà il resto di essi. Nel secondo esempio, tutti i comandi verranno eseguiti indipendentemente da cosa.

Un'altra opzione sarebbe quella di definire una funzione e usarla, ad esempio:

function cdinit() {
    cd $1
    git init
    cd ..
}

Quindi è possibile eseguire il comando:

cdinit subdir

E verrà automaticamente git initin quella directory e uscirà da essa.

Puoi anche fare una soluzione più complessa usando una funzione se hai un sacco di directory e vuoi git initfarle con un solo comando.

function cdinit() {
    for arg in $@
    do
        cd $arg
        git init
        cd ..
    done
}

È quindi possibile eseguire questo con:

cdinit subdir1 subdir2 subdir3

E lo farà git initin subdir1, subdir2e subdir3.

In caso di git(almeno nella versione 2.7.0), è possibile sfruttare l' -Copzione che fa in modo che git si comporti come se fosse stato avviato nella directory specificata. Quindi la tua soluzione potrebbe apparire come:

> git -C subdir init
Initialized empty Git repository in /some/path/subdir/.git/

Citando la documentazione:

Run as if git was started in <path> instead of the current working directory. When multiple -C options are given, each subsequent non-absolute -C
<path> is interpreted relative to the preceding -C <path>.

This option affects options that expect path name like --git-dir and --work-tree in that their interpretations of the path names would be made
relative to the working directory caused by the -C option. 

Puoi raggruppare i comandi con &&, ad es

cd subdir && git init && cd ../

Se non si desidera alcuna dipendenza dal codice di uscita di ciascun comando, è possibile utilizzare; invece, cioè:

cd subdir ; git init ; cd ../

Devi saltare nella tua directory di destinazione se il comando non ha un parametro nome file o directory.

Ma puoi scrivere uno script bash che accetta la directory di destinazione e il comando come parametri. Per questo puoi dare un'occhiata a pushd e popd: http://ss64.com/bash/pushd.html

Scriverei quel piccolo script per te, ma non ho una scatola Linux qui :)

I programmi hanno modi diversi di gestire gli argomenti, quindi alcuni avranno l'equivalente dell'opzione -folder = name . Al di là di tale eccezione, lo standard, anche su MS DOS, è semplicemente

$ programma sottodir

A volte hai bisogno

$ programma subdir /

Il programma aprirà la cartella, funzionerà allo stesso modo in cui si lavora con un file e, una volta terminato, restituirà il controllo alla shell, che è puntata sulla directory standard originale. I programmi gestiti in questo modo hanno il problema che gli output degli errori (come i core dump) vanno in un file nella directory corrente della shell (piuttosto che nel sottodir .)

Non c'è soluzione alternativa a meno che il programma non abbia opzioni di comando disponibili per specificare una posizione diversa. Alcuni programmatori ottengono la licenza artistica tra "il programma di directory è stato chiamato da " e "al programma di directory è stato detto di funzionare ".