David Behar
Rodrigo Reyes
julian orrego
Angelo Paul Yenque Tume
Andrés Alberto Godínez Cabrera
Joel Vicente Nieto Gómez
Gustavo Hernan Tiseira
JUAN SEBASTIAN RODRIGUEZ JIMENEZ
Bernardo Aguayo Ortega
Edgar Barragan
Jhon Carlos Colorado Angulo
Marcos ismael Caballero reyes
Samuel Rojas Rojas
Bernardo Aguayo Ortega
Maria Belen Vicente Sanchez
Nathaly Stefani Riaño Bejarano
Wilson Alexander Caal Pacay
Luis Fernando Hernández Ramírez
JESUS ALMIRCAR CASTELLANOS
Eliseo Ávila
Cristian Córdova
Royer Guerrero Pinilla
Camilo Leon Camacho
Henry Alexander Velásquez Rosas
Andrés Nieto
Emmanuel López
Carlos Morán
José Gregorio Block
Rodrigo Martinez
Daniel Felipe Merchan Fuquen
Diego Gonzalez
Leobardo Adrian Diaz Ruiz
Isaac Rodriguez Manjarrez
Erika Hernandez Ortiz
Sergio Estrella
Willy David Da Conceicao Lozada
José Gregorio Block
Juan Sebastián Caballero
Carlos Eduardo Diaz Polanco
Juan Pablo Calao Pérez
Diego Rubio
Juan Jose Blanco Cano
Daniel Guerrero
Oscar Eduardo Palomino Cárdenas
Gadiel Gerardo Wisar Sotelo
Forks o Bifurcaciones
Es una característica única de GitHub en la que se crea una copia exacta del estado actual de un repositorio directamente en GitHub, éste repositorio podrá servir como otro origen y se podrá clonar (como cualquier otro repositorio), en pocas palabras, lo podremos utilizar como un git cualquiera . Un fork es como una bifurcación del repositorio completo, tiene una historia en común, pero de repente se bifurca y pueden variar los cambios, ya que ambos proyectos podrán ser modificados en paralelo y para estar al día un colaborador tendrá que estar actualizando su fork con la información del original. . Al hacer un fork de un poryecto en GitHub, te conviertes en dueñ@ del repositorio fork, puedes trabajar en éste con todos los permisos, pero es un repositorio completamente diferente que el original, teniendo alguna historia en común. . Los forks son importantes porque es la manera en la que funciona el open source, ya que, una persona puede no ser colaborador de un proyecto, pero puede contribuír al mismo, haciendo mejor software que pueda ser utilizado por cualquiera. . Al hacer un fork, GitHub sabe que se hizo el fork del proyecto, por lo que se le permite al colaborador hacer pull request desde su repositorio propio.
Trabajando con más de 1 repositorio remoto
Cuando trabajas en un proyecto que existe en diferentes repositorios remotos (normalmente a causa de un fork) es muy probable que desees poder trabajar con ambos repositorios, para ésto puedes crear un remoto adicional desde consola.
git remote add <nombre_del_remoto> <url_del_remoto>
git remote upstream https://github.com/freddier/hyperblog
Al crear un remoto adicional podremos, hacer pull desde el nuevo origen (en caso de tener permisos podremos hacer fetch y push)
git pull <remoto> <rama>
git pull upstream master
Éste pull nos traerá los cambios del remoto, por lo que se estará al día en el proyecto, el flujo de trabajo cambia, en adelante se estará trabajando haciendo pull desde el upstream y push al origin para pasar a hacer pull request.
git pull upstream master git push origin master
nice!
Gracias, me aclaraste la duda sobre el flujo de trabajo con la nueva fuente.
**Apuntes! **✌🏼
Felicidades #granApunte
Excelente!!!.
Pobre anita! paso de trabajar por un sueldo a ser despedida para trabajar como una colaboradora... Señor Freddy
P.D: Excelente clase!
jajaja crack !!
jajajjaja
Solo para resaltar algo de este video, despues de hacer el clone podemos tratar de consultar las ramas que se descargaron al repositorio local con "git branch" y nos damos cuenta que solo aparece la rama master. pero y entonces... ¿que pasó con las otras ramas?
Solución: Si hacemos un "git branch --all" vamos a ver todas las ramas tanto locales como remotas y basta con cambiar de rama, por ejemplo con: "git checkout cabecera" y automaticamente se crea una copia de esta rama en el repositorio local.
Para confirmarlo haces nuevamente un "git branch" y veran que ahora si aparacen la rama master y la rama cabecera.
Gracias por tu aporte.
gracias por el aporte
Adiós Anita, siempre te recordaremos....
esta en nuestros corazones
jajjajja adiós anita
Pero que gran explicación!!! . Para subir cambios al repositorio original: .
.
Para traer cambios del repositorio original: .
git remote -v git remote add upstream [original_repository_url] git remote -v git pull upstream master
git push origin master
Gracias
Super resumen
******************* ****Iniciar Git**** ******************* git int ******************* ****Iniciar Git**** ******************* ********************************** *******Configuración de Git******* ********************************** git config git config --list git config --list --show origin git config --list --show-origin git config --global git config --global user.name "SC" git config --global user.email "jesuscastellanospaez@hotmail.com" ********************************** *******Configuración de Git******* ********************************** ******************************************** ******Agragar a la zona de preparación****** ******************************************** git add Archivo.txt git add . ******************************************** ******Agragar a la zona de preparación****** ******************************************** **************************** *********Ver estado********* **************************** git status **************************** *********Ver estado********* **************************** *************************************************************************** *****************Quitar de la zona de preparación************************** *************************************************************************** git rm --cached archivo.txt (Quitar de la zona de preparación). *************************************************************************** *****************Quitar de la zona de preparación************************** *************************************************************************** ************************************************************ **********************Realizar commint********************** ************************************************************ git commit -m "Este es el pimer commit de este archivo" git commit -am "Este es el pimer commit de este archivo" ************************************************************ **********************Realizar commint********************** ************************************************************ ***************************************************** *******Ver el historial de cambios del archivo******* ***************************************************** git log git log Archivo.txt ***************************************************** *******Ver el historial de cambios del archivo******* ***************************************************** *************************************************************** ************Muestra todos los cambios sobre un archivo********* *************************************************************** git show Archivo.txt *************************************************************** ************Muestra todos los cambios sobre un archivo********* *************************************************************** ************************************** **********Comparar versiones********** ************************************** git diff commint commint ************************************** **********Comparar versiones********** ************************************** ***************************************************************************** ************************Volver a una versión anterior************************ ***************************************************************************** git reset commit --hard (borramos todos los cambios y lo que tengamos en staging) git reset commit --soft (soft conservamos cambios y lo que tengamos en staging) git checkout (commit) Archivo.txt git checkout (rama) Archivo.txt ***************************************************************************** ************************Volver a una versión anterior************************ ***************************************************************************** **************************************************************************** **************************Ver Cambio en bytes******************************* **************************************************************************** git log --stat(Cambio en bytes) **************************************************************************** **************************Ver Cambio en bytes******************************* **************************************************************************** *************************************************************************** ****************************Crear una rama********************************* *************************************************************************** git branch (branchName) *************************************************************************** ****************************Crear una rama********************************* *************************************************************************** *************************************************************************** **************************Cambiar de rama********************************** *************************************************************************** git checkout (branchName) *************************************************************************** **************************Cambiar de rama********************************** *************************************************************************** ******************************************************************* ************************Merge entre branchs************************ ******************************************************************* git merge (branchName) **Estar en la rama master o en la que se quiere dejar el <Head>** ******************************************************************* ************************Merge entre branchs************************ ******************************************************************* **************************************************** ************Traer un repositorio externo************ **************************************************** git remote add origin (url) git remote (muestra el origen) git remote -v(es verval) git pull origin master --allow-unrelated-histories (Fuerza la union de las diferentes historias) git pull origin master (Descarga cambios) git push (origin) (master) (Sube Cambios) **************************************************** ************Traer un repositorio externo************ **************************************************** ************************************* **************Seguridad************** ************************************* ssh-keygen -t rsa -b 4096 -C "jesuscastellanospaez@gmail.com" (crea la llave publica y privada) eval $(ssh-agent -s) (saber si el agente ssh esta ejecuntando) ssh-add ~/.ssh/id_rsa (agregar la llave privada) git remote set-url origin git@github.com:gsuscastellanosSC/hyperblog.git (cambiar url para que sea con ssh) ************************************* **************Seguridad************** ************************************* ********************************** ***************TAGS*************** ********************************** git log --all(Muesta toda la historia) git log --all --graph (Muestra toda la historia con la ineracción de las ramas) git log --all --graph --decorate --oneline alias arbolito="git log --all --graph --decorate --oneline"(forma de alias en linux) git tag -a v0.1 -m "apendiendo tags en git" (hash del commit) (crear un tag) git show-ref --tags git push origin --tags (enviar los tags al repositorio remoto) git tag -d v0.1 && $ git push origin :refs/tags/v0.1 (Borrar tags) ********************************** ***************TAGS*************** ********************************** ************************ ********ramas*********** ************************ git show-branch --all (¿Cuales branch existen y sus historias) gitk (igual que la anterior per con gui) git push origin :[nombre_branch] (Elimina rama remota) ************************ ********ramas*********** ************************ ************************ ***Crear fuente nueva*** ************************ git remote add upstream (url-github) git pull upstream master (trae todos los cabios de master del origen upstream) ************************ ***Crear fuente nueva*** ************************
Magnífico, mil gracias!!!
F por Anita ;(
F
F
Apuntes 😪🥴
Eres grande hermano, la verdad no sé cómo te mantienes en pie para hacer los apuntes hasta esta clase, me da ánimos de seguir. Graciaaas!!!
F por Anita
Para hacer una contribución a un proyecto de Github hay que seguir los siguientes pasos:
Pero también pasa algo muy interesante y es que cuando yo he hecho un fork, el proyecto original sigue avanzando y el mio se va quedando atras, así que para traer los cambios del proyecto original eso se hace de la siguiente manera:
#Nice
1 Segundo de silencio por Ana... Gracias```
Buenas Tiene notas de todo el curso?
Gracias por compartir :D
Anita en estos momentos...
jajajaaaja
Todos los pasos del video aqui: Sacamos a anita del proyecto (ya no tiene permisos de merge, push solo puede clonarlo).
Desde la cuenta de anita abrimos el proyecto, le damos watch(podemos ver conversaciones), estrellita (indicador de que este proyecto me gusta, me llegan avisos cuando algo cambia),y un fork es tomar una copia a nuestros repositorios (https://geeksroom.com/2014/05/que-es-un-fork-y-como-trabajar-en-github/85588/) PARA HACER CAMBIOS DESDE LA CUENTA DE ANITA, HAY QUE TRAERNOSLO A NUESTRO PROPIO REPOSITORIO LOCAL. Anita: $ git clone url_delRepoRemoto_de anita(el fork) Modifico los errores ortográficos con entidades HTML y un commit ($git commit –am “Tildes con entidades y mensaje de contribución”) y $git push PARA PODER CREAR ESE PULL REQUEST (HACER UN MERGE) ENTRE UN PROYECTO Y OTRO Le damos en new pull request nos abre esta interfaz y nos dice (Elija dos ramas para ver qué ha cambiado y empezar un nuevo pull request. Si lo necesita, también puede comparar los diferentes forks.) Seleccionamos de derecha a izquierda (compare:master – mi master de mi repo) a base: master del repo original. Mas abajo vemos los cambios realizados. Luego le damos en créate pull request y lo enviamos. Ahora toca esperar a que realicen estos cambios.
VAMOS A MI CUENTA: Vemos que anita quiere fisionar un commit de su rama master a mi rama master. Lo único que tenemos que preocuparnos es de cuales son los cambios. Los aprobamos los cambios y le decimos OK y le damos Merge pull request(confirmo el merge). Y vemos los cambios que ella hizo y si le damos a commits también puedo ver los commits que anita realizo
ANITA EN ESTE MOMENTO TIENE UN FORK, LO QUE SIGNIFICA QUE SI YO HAGO CAMBIOS ANITA DEBE DE TRAERSELOS EN SU PROPIO FORK, PORQUE SE VA QUEDANDO ATRÁS. Realizamos cambios al archivo original desde Willy (al title). Nos traemos los cambios de anita con $git pull origin master. Nos lanza un error que dice tus cambios locales de tus siguientes archivos van a ser resuscritos por el merge (blogpost.html) no importa que este modificado el archivo. Realizamos el commit ($ git commit -am "Cambio de titulo“) para que los fucione.(no genera ningun conflito). Volvemos a ejecutar git pull origin master (si queremos fusionar los câmbios de la rama master com los cambios que realizamos en remoto) $git push origin master (para enviar los cambios que yo hice)
EN ESTE MOMENTO ANITA TIENE UN PROBLEMA PORQUE HYPERBLOG (BLOG2) ESTA MAS ADELANTADO QUE EL DE ANITA. TENEMOS QUE TRAERLO Anita: vamos al repositorio de anita desde su cuenta vemos los commits que hubieron Podemos comparar y vemos los cambios de allá para aca para ver cambios. Le podemos dar a créate pull request, esto me crea un pull request de Willy a anita darle merge y listo.
PARA TRAERME LOS CAMBIOS DESDE CONSOLA. CREAREMOS OTRA FUENTE PARA HACER PULL: $ git remote add upstream url_https (esto para generar otra fuente nueva donde podemos traer datos a nuestra rama master) $ git pull upstream master (con esto nos traemos todos los cambios de master) $ git commit –am “Fusion” (pero no hay nada a que hacerle commit porque ya nos traemos todo) $ git push origin master (mandamos a nuestro repositorio original)
CONCEPTOS Y FUNDAMENTOS: Fork: Significa tenedor, es tomar una copia del estado actual del proyecto y clonarlo como un proyecto mio. (SOLO PROYECTOS PUBLICOS,Y ES UNA CARACTERISTICA UNICA DE GITHUB.)
Hay dos maneras de actualizar mi fork del repo original, por consola o por github por consola simplemente hay que crear otra fuente remota para fusionar el remoto original con el fork en local y luego subirlo a el fork en remoto.
#Gracias
En esta clase más allá de entender el PullRequest se ven las ventajas siendo un no-colaborador, simplemente alguien que quiera aportar. La clonación a través de un Fork es similar a enlazar un repositorio:
$git clone URL o SSH (Clona el proyecto)
Para mantener actualizado este Fork es de utilidad tener un upstream que es un puntero a la rama master del proyecto principal, se logra enlazando una rama a la rama master del proyecto original:
$git remote add upstream URLdelOriginal (Enlaza con el master original)
A partir de upstream ya se pueden tener los cambios recientes en la rama master bifurcada.
Espero que les ayude.
Gracias!
"Adiós Anita, que la fuerza te acompañe"
ahora vende arepas
segundo 20 del video y ya extraño a Anita :'(
jaja
Cuando no eres un colaborador directo, sino que es un proyecto open source, no puede hacer push o merge, porque no es tu proyecto. Lo que se puede hacer es un fork, hacer los cambios y decirles "quiero colaborar, pro favor, revisen este código". En los proyectos open source para que te lleguen notificaciones de cuándo se realizan cambios hay que darle clic al botón "watch" y luego darle clic a fork, fork lo que hace es tomar una copia del proyecto y clonarlo, esto solo es posible si el proyecto es público, si el proyecto es privado es imposible saber que el proyecto existe. Una vez el proyecto ha sido forkeado, aparecerá una copia en la interfaz del usuario en github, luego, se clona por https o ssh, y se importa en el disco local con "git clone URLDelProyecto". Luego se hace un git commit, git push origin master, pero esto se actualizará en tu repositorio, no en el repositorio oficial. Para hacer el pull request con la rama oficial, se debe crear un pull request, luego se coloca un título, un comentario y luego enviarlo. Desde la perspectiva del propietario, es el mismo procedimiento de code review, revisa los cambios y los acepta o no. Ahora el proyecto oficial está más adelantado que el mío, desde github es tan fácil como revisar los cambios desde su interfaz visual, hacer un pull request de los cambios y luego un merge, nada del otro mundo, desde consola es lo interesante. se crea un nuevo origen remoto con git remote add nombreRemoto URLDelProyecto, y listo, ya se puede hacer pull del repositorio remoto oficial y luego push de nuestro repositorio remoto a github.
Gracias amigo por tu aporte! , me sirvió mucho
