tutorial - guardar credenciales git

¿Cómo evito escribir "git" al comienzo de cada comando de Git?

Question

Me pregunto si hay una manera de evitar tener que escribir la palabra git al comienzo de cada comando de Git.

Sería bueno si hubiera una manera de usar el comando git solo una vez al principio después de abrir un indicador de comandos para entrar en el "modo Git" .

Por ejemplo:

git>

Después de lo cual, cada comando que escribimos se interpreta por defecto como un comando Git.

De una manera similar a cómo usamos el shell de MySQL para escribir comandos de base de datos:

mysql>

Esto me salvará de escribir ''git'' cientos de veces todos los días.

NOTA: Estoy usando git-bash , en Windows.

Answer 1

Aquí hay otra manera. Tampoco es exactamente lo que se preguntó, pero lo he estado usando durante algún tiempo y es bastante bueno. Agregue la siguiente línea a su ~/.bashrc :

complete -E -W git

Ahora presionando Tab en un indicador de Bash vacío se escribirá "git".

Answer 2

En su ejemplo, lo compara con un indicador de MySql. La forma en que funciona es que se inicia un proceso MySql y le das tus comandos a ese proceso. Como tal, ¿por qué no escribir algo similar en el idioma de su elección? Aquí hay un ejemplo simple en C ++:

#include <iostream>
#include <cstdlib>

int main(int argc, char *argv[]){
    while(true){
        std::cout << "git> ";
        std::cout.flush();
        std::string command;
        std::getline(std::cin, command);
        if(command == "exit") break;
        std::system("git " + command);
    }

    return 0;
}

Tenga en cuenta que escribí eso de memoria y que no lo comprobé con un compilador. Puede haber errores de sintaxis triviales.

Answer 3

Es posible que desee probar gitsh . De su readme:

El programa gitsh es un shell interactivo para git. Desde dentro de gitsh puede emitir cualquier comando de git, incluso utilizando sus alias locales y configuración.

• Los comandos de Git tienden a venir en grupos. Evite escribir git una y otra vez ejecutándolos en un shell de git dedicado:

sh$ gitsh
gitsh% status
gitsh% add .
gitsh% commit -m "Ship it!"
gitsh% push
gitsh% ctrl-d
sh$

O eche un vistazo a los otros proyectos vinculados allí:

• git-sh : un shell bash personalizado con un indicador de Git, alias y finalización.
• gitsh - Un simple shell de Git escrito en Perl.
• repl - Envuelve cualquier programa con subcomandos en un REPL.

Nota: no he usado esto yo mismo.

Answer 4

Esto no es exactamente lo que está pidiendo, pero podría configurar algunos alias de shell en su ~/.bashrc para los comandos Git que usa con más frecuencia:

alias commit=''git commit''
alias checkout=''git checkout''
...

También tenga en cuenta que puede crear alias dentro de Git:

git config --global alias.ci commit
git config --global alias.co checkout
...

Esto le permite escribir git ci lugar de git commit , y así sucesivamente.

Answer 5

Otro enfoque que funcionará con cualquier comando: use Ctrl + R (reverse-i-search).

La búsqueda inversa le permite buscar su historial de comandos. Repita Ctrl + R después de presionar la cadena de búsqueda para repetir la búsqueda más atrás con la misma cadena.

Solo necesita escribir un comando una vez, luego puede recuperar ese comando de cualquier subcadena del comando. En la mayoría de los casos, puede recordar comandos muy largos y sus distintas variantes con solo dos o tres letras de búsqueda bien ubicadas. No se necesitan preconfiguraciones más que usar su shell normalmente y es autoadaptativo a cómo usó la shell, simplemente escriba el comando completo una vez y los comandos se agregarán automáticamente a su historial de comandos.

• git commit --amend : <Ctrl+R>am
• git pull : <Ctrl+R>pu
• git rebase --rebase-merges -i --onto origin/develop origin/develop feature/blue-header : <Ctrl+R>blu
• git rebase --abort : <Ctrl-R>ab
• git rebase --continue : <Ctrl-R>con
• docker-compose stop && git pull && make && docker-compose up -d : <Ctrl-R>up
• etc

Además, Ctrl-R funciona no solo en bash, sino en muchos programas que usan la biblioteca readline (y hay muchos de ellos), como Python shell, IPython, mysql shell, psql shell, irb (ruby), etc.

Answer 6

Para cosas básicas, puedes hacer:

function ggit(){ while true; do; printf ''git> ''; read; eval git $REPLY; done }

git> status
On branch master
Your branch is ahead of ''origin/master'' by 1 commit.
  (use "git push" to publish your local commits)

Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    deleted:    yarn.lock

no changes added to commit (use "git add" and/or "git commit -a")
git> add .
git> status
On branch master
Your branch is ahead of ''origin/master'' by 1 commit.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    deleted:    yarn.lock

git>

Salir con ctrl + c

Answer 7

Sé que esta es una respuesta muy tardía, pero esta pregunta realmente me llamó la atención porque he estado lidiando con el sufrimiento de este tipo de repetición durante bastante tiempo.

No estoy seguro de ti, pero sinceramente no (repito NO ) quiero crear alias para cada comando de git , así que escribí un script de python llamado NoGit para resolver este problema:

#!/usr/bin/env python
import sys, os, signal, atexit, readline, subprocess

commands, stop, history_file = [], False, os.path.join(os.getcwd(), "git.history")

def run_commands():
  stop = True
  for cmd in commands:
    command = ["git" if not cmd.startswith("git ") else ""]
    command = [cmd] if command[0] == "" else [command[0], cmd]
    subprocess.Popen(command).communicate()
    commands = []

def signal_handler(sig, frame):
  run_commands()
  sys.exit(0)

try:
  readline.read_history_file(history_file)
  signal.signal(signal.SIGINT, signal_handler)

  while True:
    if stop == True:
      break
    command = input("git> ")
    if command == "%undo":
      commands.pop()
    elif command == "%run":
      run_commands()
    elif command == "%exit":
      sys.exit(0)
    else:
      commands += [cmd.strip() for cmd in command.split(";")]

  signal.pause()
  readline.set_history_length(-1)
except IOError:
  pass

atexit.register(readline.write_history_file, history_file)

NoGit es un simple script de Python para evitar la repetición innecesaria de la palabra clave "git".

Documentación:

• el comando %undo elimina el último comando de la pila
• el comando %run ejecuta los comandos en la pila y borra la pila
• El comando %exit cierra el CLI sin hacer nada.
• presionar ctr+c es lo mismo que ejecutar %run; %exit %run; %exit
• la secuencia de comandos guarda los comandos que se ejecutaron en un archivo llamado git.history en la misma carpeta que la secuencia de comandos
• puede agregar varios comandos en una línea usando un punto y coma
• puede usar la palabra clave git al principio del comando y la secuencia de comandos no la duplicará (por ejemplo, git init no se convierte en git git init )

Ejemplos de comandos:

1. init
2. add .
3. stage .
4. commit -m "inital commit"
5. %run; %exit

Información adicional (para usuarios de Linux):

Si lo deseas, puedes eliminar la extensión .py y convertirla en un ejecutable usando:

mv ./git.py ./git
chmod +x ./git

Entonces, en lugar de llamar al script de esta manera:

python3 git.py

Usted ejecutaría esto en su lugar:

./git

Información adicional (para personas perezosas):

Si es perezoso y no quiere escribir un ./ , puede mover este script a su carpeta /bin/ y crear un alias para él.

Si eres realmente perezoso, usa los siguientes comandos:

sudo cp ./git /bin/nogit
sudo chmod +x /bin/nogit
alias nogit=''/bin/nogit''

Si es realmente perezoso, copie y pegue lo siguiente:

sudo cp ./git /bin/nogit && sudo chmod +x /bin/nogit && alias nogit=''/bin/nogit''

Si tu pereza ha alcanzado niveles previamente desconocidos para la humanidad, aquí hay una versión más compacta del mismo one-liner:

sudo cp ./git /bin/nogit;sudo chmod +x /bin/nogit;alias nogit=''/bin/nogit''

Buena suerte.

Answer 8

Soy un gran fan de usar alias en ~ / .bash_profile para mi GitBash. Si sigues este enfoque, aquí están algunos de mis favoritos:

# git
alias gw=''git whatchanged''
alias gg=''git grep -n -C8''
alias ggi=''git grep -i -n -C8''
alias gb=''git branch''
alias gbd=''git branch -D''
alias gba=''git branch -a''
alias gc=''git checkout''
alias gcp=''git cherry-pick''
alias gfo=''git fetch origin''
alias s=''git status''
alias gmom=''git merge origin/master''
alias grom=''git rebase origin/master''
alias gpom=''git pull origin master''
alias pplog=''git log --oneline --graph --decorate''

Answer 9

Un amigo mío hizo un pequeño guión de bash que logra esto. Se llama Replify .

$ replify git
Initialized REPL for [git]
git> init
Initialized empty Git repository in /your/directory/here/.git/

git> remote add origin https://your-url/repo.git

git> checkout -b new-branch
Switched to a new branch ''new-branch''

git> push

Answer 10

Un perl de una sola línea que hará esto:

perl -nE ''BEGIN {print "git > "} system "git $_"; print "git > "''

Esto ejecutará lo que escriba, prefijado con git . Y seguirá haciendo eso hasta que golpees ^D

Answer 11

Usa tu editor.

Escriba el comando como commit desde su editor favorito como código vs y sea más eficiente con git:

O escribe git para obtener todos los comandos: