subir - que es un commit en git

¿Cómo puedo determinar la URL desde la que se clonó originalmente un repositorio Git local?

Question

Saqué un proyecto de GitHub hace unos días. Desde entonces, he descubierto que hay varias bifurcaciones en GitHub, y no me di cuenta de cuál tomé originalmente. ¿Cómo puedo determinar cuál de esos tenedores tiré?

Answer 1

Para obtener la dirección IP / nombre de host de origin

Para ssh:// repositorios:

git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d "/"

Para git:// repositorios:

git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d ":"

Answer 2

Con git remote show origin tienes que estar en el directorio de proyectos. Pero si desea determinar las URL de cualquier otro lugar, puede utilizar:

cat <path2project>/.git/config | grep url

Si necesita este comando a menudo, puede definir un alias en su .bashrc o .bash_profile con MacOS.

alias giturl=''cat ./.git/config | grep url''

Así que solo necesitas llamar a giturl en la carpeta raíz de Git para simplemente obtener su URL.

Si extiendes este alias como este

alias giturl=''cat .git/config | grep -i url | cut -d''='' -f 2''

obtienes solo la URL simple sin la anterior

"url ="

en

url = http://example.com/repo.git

Obtienes más posibilidades en su uso:

Ejemplo

En Mac, puede llamar a open $(giturl) para abrir la URL en el navegador estándar.

O chrome $(giturl) para abrirlo con el navegador Chrome en Linux.

Answer 3

Con Git 2.7 (lanzamiento el 5 de enero de 2015), tiene una solución más coherente utilizando git remote :

git remote get-url origin

(bonito colgante de git remote set-url origin <newurl> )

Ver commit 96f78d3 (16 de septiembre de 2015) por Ben Boeckel ( mathstuf ) .
^{(Fusionada por Junio ​​C Hamano - gitster - in commit e437cbd , 05 de octubre de 2015)} :

remoto: añadir subcomando get-url

Expandir en lugar de insteadOf es una parte de ls-remote --url y no hay forma de expandir también pushInsteadOf .
Agregue un subcomando get-url para poder consultar tanto como una forma de obtener todas las URL configuradas.

get-url:

Recupera las URL para un control remoto.
pushInsteadOf se expanden las configuraciones de las insteadOf en lugar de insteadOf y pushInsteadOf .
Por defecto, solo se enumera la primera URL.

• Con '' --push '', las URL de inserción se consultan en lugar de obtener las URL.
• Con '' --all '', se mostrarán todas las URL para el control remoto.

Antes de git 2.7, tenías:

 git config --get remote.[REMOTE].url
 git ls-remote --get-url [REMOTE]
 git remote show [REMOTE]

Answer 4

Creo que puedes encontrarlo en .git/config y remote["origin"] si no lo manipulaste.

Answer 5

El control remoto del canal ascendente no se puede llamar "origen", así que aquí hay una variación:

remote=$(git config --get branch.master.remote)
url=$(git config --get remote.$remote.url)
basename=$(basename "$url" .git)
echo $basename

O:

basename $(git config --get remote.$(git config --get branch.master.remote).url) .git

Para más variables útiles hay:

$ git config -l

Answer 6

Imprimir URL de captura remota con nombre arbitrario:

git remote -v | grep fetch | awk ''{print $2}''

Answer 7

La URL de Git estará dentro del archivo de configuración de Git. El valor corresponde a la clave url :

 cd project_dir
 cat .git/config | grep url | awk ''{print $3}''

Answer 8

Nunca puedo recordar todos los parámetros de los comandos de Git, así que solo puse un alias en el archivo ~/.gitconfig que tiene más sentido para mí, así que puedo recordarlo, y resulta en menos escritura:

[alias]
url = ls-remote --get-url

Después de volver a cargar el terminal, puede simplemente escribir:

> git url

Aquí hay algunos más de mis de uso frecuente:

[alias]
cd = checkout
ls = branch
lsr = branch --remote
lst = describe --tags

Answer 9

Para complementar las otras respuestas: si, por alguna razón, se ha cambiado el control remoto y no refleja el origen original , la primera entrada en el reflog (es decir, la última entrada mostrada por el comando git reflog ) debe indicar dónde estaba el repositorio. originalmente clonado de.

p.ej

$ git reflog | tail -n 1
f34be46 HEAD@{0}: clone: from https://github.com/git/git
$

(Tenga en cuenta que el reflog puede ser purgado, por lo que no se garantiza que funcione).

Answer 10

Para obtener la respuesta:

git ls-remote --get-url [REMOTE]

Esto es mejor que leer la configuración; Consulte la página del manual de git-ls-remote :

--get-url

Expanda la URL del repositorio remoto dado teniendo en cuenta cualquier configuración de configuración "url.<base>.insteadOf" (consulte git-config(1) ) y salga sin hablar con el control remoto.

Como lo señaló @Jefromi, esta opción se agregó en v1.7.5 y no se documentó hasta v1.7.12.2 (2012-09).

Answer 11

Para resumir, hay al menos cuatro formas:

(Lo siguiente fue probado para el repositorio oficial de Linux)

Menos información:

$ git config --get remote.origin.url
https://github.com/torvalds/linux.git

y

$ git ls-remote --get-url
https://github.com/torvalds/linux.git

Más información:

$ git remote -v
origin    https://github.com/torvalds/linux.git (fetch)
origin    https://github.com/torvalds/linux.git (push)

Incluso más información:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/torvalds/linux.git
  Push  URL: https://github.com/torvalds/linux.git
  HEAD branch: master
  Remote branch:
    master tracked
  Local branch configured for ''git pull'':
    master merges with remote master
  Local ref configured for ''git push'':
    master pushes to master (up to date)

Answer 12

Puedes probar:

git remote -v

Imprimirá todas las URL de búsqueda / inserción de sus controles remotos.

Answer 13

Respuesta corta:

$ git remote show -n origin

o, una alternativa para scripts puros y rápidos:

$ git config --get remote.origin.url

Alguna información:

1. $ git remote -v imprimirá todos los controles remotos (no lo que desea). ¿Quieres origen verdad?
2. $ git remote show origin mucho mejor, muestra solo el origin pero tarda demasiado (probado en la versión 1.8.1.msysgit.1 de git)

Terminé con: $ git remote show -n origin , que parece ser el más rápido. Con -n no recuperará cabezas remotas (ramas AKA). No necesitas ese tipo de información, ¿verdad?

http://www.kernel.org/pub//software/scm/git/docs/git-remote.html

Puede aplicar | grep -i fetch | grep -i fetch las tres versiones para mostrar solo la URL de búsqueda.

Si requiere velocidad pura, entonces use:

$ git config --get remote.origin.url

Gracias a @Jefromi por señalarlo.

Answer 14

Si desea esto para fines de scripting, solo puede obtener la URL con

git config --get remote.origin.url

Answer 15

Si desea solo la URL remota o la integridad referencial se ha roto:

git config --get remote.origin.url

Si necesita salida total o la integridad referencial está intacta:

git remote show origin

Cuando se usa git clone (de GitHub, o cualquier otro repositorio de origen), el nombre predeterminado para la fuente del clon es "origen". El uso de git remote show mostrará la información sobre este nombre remoto. Las primeras líneas deben mostrar:

C:/Users/jaredpar/VsVim> git remote show origin
* remote origin
  Fetch URL: [email protected]:jaredpar/VsVim.git
  Push  URL: [email protected]:jaredpar/VsVim.git
  HEAD branch: master
  Remote branches:

Si desea usar el valor en la secuencia de comandos, usaría el primer comando listado en esta respuesta.

Answer 16

Si no conoce el nombre del control remoto en sentido ascendente para una rama, puede buscarlo primero inspeccionando el nombre de la rama en sentido ascendente sobre el que se construyó la rama actual. Utilice git rev-parse así:

git rev-parse --symbolic-full-name --abbrev-ref @{upstream}

Esto muestra la rama ascendente que fue la fuente de la rama actual. Esto se puede analizar para obtener el nombre remoto como este:

git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1

Ahora toma eso y llévalo a git ls-remote y obtendrás la URL del control remoto que es la fuente de la rama actual:

git ls-remote --get-url /
  $(git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1)

Ahora se debe tener en cuenta que esto no es necesariamente el mismo que el repositorio remoto de origen que se clonó. En muchos casos, sin embargo, será suficiente.

Answer 17

Una forma sencilla es abrir el archivo .git/config :

cat .git/config

Para editar:

vim .git/config o

nano .git/config

Answer 18

Yo básicamente uso:

git remote get-url origin

Funciona para la consola de comandos de Git Bash o la consola de comandos de CMD en Windows. Dicho esto, funciona con la versión 2.x de Git.

Answer 19

#!/bin/bash

git-remote-url() {
 local rmt=$1; shift || { printf "Usage: git-remote-url [REMOTE]/n" >&2; return 1; }
 local url

 if ! git config --get remote.${rmt}.url &>/dev/null; then
  printf "%s/n" "Error: not a valid remote name" && return 1
  # Verify remote using ''git remote -v'' command
 fi

 url=`git config --get remote.${rmt}.url`

 # Parse remote if local clone used SSH checkout
 [[ "$url" == git@* ]] /
 && { url="https://github.com/${url##*:}" >&2; }; /
 { url="${url%%.git}" >&2; };

 printf "%s/n" "$url"
}

Uso:

# Either launch a new terminal and copy `git-remote-url` into the current shell process, 
# or create a shell script and add it to the PATH to enable command invocation with bash.

# Create a local clone of your repo with SSH, or HTTPS
git clone [email protected]:your-username/your-repository.git
cd your-repository

git-remote-url origin

Salida:

https://github.com/your-username/your-repository