DI Desarrollo de Interfaces .

COMO TRABAJAR CON GIT ……………..

En primer lugar veremos los comandos que vamos a utilizar en Git.

1. git help comando ó git comando –help

Muestra la ayuda para ese comando

b) Creación de un repositorio:

2. git init

Crea un repositorio en el directorio actual

3. git clone url

Clona un repositorio remoto dentro de un directorio

c) Operaciones sobre Archivos:

4. git add path

Adiciona un archivo o un directorio de manera recursiva

5. git rm ruta

Remueve un archivo o directorio del árbol de trabajo

-f : Fuerza la eliminación de un archivo del repositorio

6. git mv origen destino

Mueve el archivo o directorio a una nueva ruta

-f : Sobre-escribe los archivos existentes en la ruta destino

7. git checkout [rev] archivo

Recupera un archivo desde la rama o revisión actual

-f : Sobre-escribe los cambios locales no guardados

d) Trabajando sobre el código:

8. git status

Imprime un reporte del estado actual del árbol de trabajo local

9. git diff [ruta]

Muestra la diferencia entre los cambios en el árbol de trabajo local

10. git diff HEAD ruta

Muestra las diferencias entre los cambios registrados y los no registrados

11. git add path

Selecciona el archivo para que sea incluido en el próximo commit

12. git reset HEAD ruta

Marca el archivo para que no sea incluido en el próximo commit

13. git commit

Realiza el commit de los archivos que han sido registrados (con git-add)

-a : Automáticamente registra todos los archivos modificados

14. git reset –soft HEAD^

Deshace commit & conserva los cambios en el árbol de trabajo local

15. git reset –hard HEAD^

Restablece el árbol de trabajo local a la versión del ultimo commit

16. git clean

Elimina archivos desconocidos del árbol de trabajo local

e) Examinando el histórico:

17. git log [ruta]

Muestra el log del commit, opcionalmente de la ruta especifica

18. git log [desde [..hasta]]

Muestra el log del commit para un rango de revisiones dado

–stat : Lista el reporte de diferencias de cada revisión

-S’pattern’ : Busca el historial de cambios que concuerden con el patrón de búsqueda

19. git blame [archivo]

Muestra el archivo relacionado con las modificaciones realizadas

f) Repositorios remotos:

20. git fetch [remote]

Trae los cambios desde un repositorio remoto

21. git pull [remote]

Descarga y guarda los cambios realizados desde un repositorio remoto

22. git push [remote]

Guarda los cambios en un repositorio remoto

23. git remote

Lista los repositorios remotos

24. git remote add remote url

Añade un repositorio remoto a la lista de repositorios registrados

g) Ramas:

25. git checkout rama

Cambia el árbol de trabajo local a la rama indicada

-b rama : Crea la rama antes de cambiar el árbol de trabajo local a dicha rama

26. git branch

Lista las ramas locales

27. git branch -f rama rev

Sobre-escribe la rama existente y comienza desde la revisión

28. git merge rama

Guarda los cambios desde la rama

h) Exportando e importando:

29. git apply – < archivo

Aplica el parche desde consola (stdin)

30. git format-patch desde [..hasta]

Formatea un parche con un mensaje de log y un reporte de diferencias (diffstat)

31. git archive rev > archivo

Exporta resumen de la revisión (snapshot) a un archivo

–prefix=dir/ : Anida todos los archivos del snapshot en el directorio

–format=[tar|zip] : Especifica el formato de archivo a utilizar: tar or zip

i) Etiquetas:

32. git tag name [revision]

Crea una etiqueta para la revisión referida

-s : Firma la etiqueta con su llave privada usando GPG

-l [patrón] : Imprime etiquetas y opcionalmente los registros que concuerden con el patrón de busqueda

j) Banderas de Estado de los Archivos:

M (modified) : El archivo ha sido modificado

C (copy-edit) : El archivo ha sido copiado y modificado

R (rename-edit) : El archivo ha sido renombrado y modificado

A (added) : El archivo ha sido añadido

D (deleted) : El archivo ha sido eliminado

U (unmerged) : El archivo presenta conflictos después de ser guardado en el servidor (merge)


 

 

Vamos crear un Proyecto en el que crearemos un Repositorio

en Windows y en Linux .

En Windows

1 Cd para ir a la Carpeta creada en nuestro escritorio.

2 git config –global user.name “Windows”.

3 git config –global user.email “tu email”.

4 git clone htt//:la url de Git.

5 cd actividades el nombre de la actividad que hayas puesto en Git.

6 git log

7 Vamos a la carpeta de Holamundo y hago cambios.

8 git add Holamundo.java

9 git commit -m “Añado modificacion”.

10 gitK

11 git push origin master

Como fusionar ?

fit merge origin/master

Como crear una nueva rama ?

git branch nombre.

git checkoot nombre

Vamos a la carpeta y modificamos

git add Holamundo.java

git conmit -n “Commit en Holamundo.java”

Vamos a la carpeta y ponemos otro System

git commit -n “Aqui otra modificacion”.

gitk

Vemos los cambios.

git fetch origin

git log –no.merges origin/master ^ nombre

git checkool master

Vamos a Fusionar

git merge nombre

gitk

Sincronizar con Remoto

git merge origin/master

Vamos a la carpeta creada y quitamos los Head .

En Linux:

git config –global user.name “Linux”

sudo su

Abrimos gitHub

Buscamos la URL

git clone http:………………. URL

cd ActividadesdeParejas

Hacemos los cambios.

namo Holamundo.java

System.out.println(“Hola “);

Control o , Control x para salir.

git add Holamundo.java

git commit -n “Añado Holamundo”

gitk

git push origin master

Si da ERROR………..

git fecth origin

gitkç

Vamos a Fusionarlo.

git merge origin/master

nano Holamundo.java

Quitamos el Head y las rayas solo dejamos los metodos.

Confirmar Conflictos.

git conmit -n “Resolvemos conflictos”

gitk

git push origin master

user:

email:

 


 

Utilizar git dentro de Netbeans.

El IDE Netbeans, cuenta con soporte nativo para Git en todos los proyectos que manejamos dentro del IDE, una vez que comenzamos a versionar un proyecto, Netbeans nos mostrará cambios, eliminaciones y archivos o componentes agregados al proyecto. Para utilizar Git desde Netbeans podemos inicializar un repositorio en algún proyecto existente, o clonar un proyecto que ya está versionado desde Netbeans.

Inicializar un repositorio Git en un proyecto existente de Netbeans.

Si ya tenemos iniciado algún proyecto en Netbeans y queremos comenzar a versionarlo con Git, simplemente hacemos clic derecho sobre nuestro proyecto (En el explorador de proyectos), a continuación hacemos clic en Versioning – – > Inicialize Git Respository.

Luego de esto Netbeans nos pedirá que seleccionemos un directorio para el repositorio, por default nos pondrá el directorio en el que se almacena nuestro proyecto, preferentemente utilizaremos este directorio.

Elige carpeta para el repositorio

Listo, ahora nuestro proyecto sera versionado por Git aprovechando las herramientas de análisis de versiones que Netbeans provee.

Clonar un repositorio Github desde Netbeans.

Si antes de utilizar git dentro de Netbeans, ya tenemos algún proyecto alojado en Github o si queremos descargar el source de algun proyecto de código libre que utilice git para versionar su código podemos hacerlo sin problemas desde Netbeans. Para ello vamos a el menu: Team – – > Git – – > Clone…

Team >> Git >> Clone

A continuación Netbeans nos pedirá la URL del repositorio que pretendemos clonar, como ejemplo utilizaré la URL del proyecto LearningSpringIO para lo cual desde github abro el repositorio y copiamos la URL que aparece del lado derecho bajo la etiqueta: ‘https Clone url’ y la pegamos en la ventana correspondiente de Netbeans.

Https clone url

Además de pegar la dirección del repositorio, también introducimos nuestro usuario y contraseña de Github.

introducing clone url - user - password

Posteriormente hacemos clic en Next y a continuación elegimos la rama que deseamos clonar, en este caso la rama ‘master’ y hacemos clic en ‘Next’.

En la siguiente ventana, elegimos en que directorio deseamos que se clone el proyecto, así como el nombre que le daremos a nuestro repositorio (De preferencia dejar el que viene por default), activamos la casilla que dice: ‘Scan for netbeans projects after Clone’ y hacemos clic en ‘Finish’.

Save directory for repo

Con esto se habrá clonado el proyecto y podremos abrirlo desde Netbeans. 🙂

Subiendo nuevos archivos y cambios a nuestro repositorio Github.

Ahora supongamos que hemos pasado un tiempo trabajando en nuestro proyecto, hemos hecho algunos cambios, resuelto algunos bugs y agregado nuevos componentes. podremos ver que netbeans nos resalta los cambios en color azul y los nuevos archivos en verde en el explorador de proyectos. Para subir nuevos cambios seguiremos siempre dos sencillos pasos: Commit y Push. Para el primero, hacemos clic derecho sobre nuestro proyecto y elegimos Git – – > Commit, en la ventana que aparece podemos introducir algún comentario que distinguirá este commit de los demás. También podemos elegir los archivos nuevos o con modificaciones que se enviaran al repositorio. Por default todos los archivos nuevos o con modificaciones aparecen seleccionados.

Making commit

Hacemos clic en el botón ‘commit’ y listo, nuestros cambios se han enviado al repositorio local. Ahora para subirlos al repositorio Github, nuevamente hacemos clic con el botón secundario sobre nuestro proyecto y elegimos: ‘Git — > Remote – – > Push …’

En la ventana emergente debemos introducir el repositorio remoto, nuestro usuario y contraseña de Github, lo cual Netbeans ya hace por nosotros, así que en la mayoría de los casos, nos limitaremos a hacer clic en ‘Next’ .

Push to remote repository

En la siguiente ventana elegimos la rama o branch a la cual subiremos los cambios, y hacemos clic en ‘Next’ y después en ‘Finish’ si no hay ningún conflicto, nuestros cambios se subirán a Github y estarán disponibles para los demás miembros del proyecto.

Bajar cambios hechos por otros a nuestro repositorio local.

En caso de que alguien más haya subido cambios al repositorio Github o en cualquier caso queramos actualizar nuestro repositorio local con el de Github, debemos hacer un pull para lo cual nuevamente hacemos clic derecho sobre nuestro proyecto y elegimos: ‘Git – – > Remote – – > Pull …’ y se lanzará un ventana con los datos del repositorio y nuestro usuario – contraseña de github. Hacemos clic en Next , a continuación elegimos la rama que queremos revisar y hacemos clic en Finish. Con esto nuestro proyecto local se actualizara con los ultimos cambios encontrados en Github.

Como utilizar los comandos en NetBeans.

 

 

Control de versiones utilizando Subversion

 

 

 

 

Subversion es un sistema centralizado de control de versiones. En otras palabras, es un sistema que permite llevar el control de los cambios realizados por una o mas personas a una serie de documentos a través del tiempo.

Sin título

 

 

JavaAplication ->Boton derecho ->Git->Hay podemos elegir los comandos que queremos utilizar.

Instalación de Subversion

Uno de los sistemas de control de versiones mas utilizados en la actualidad es Subversion. Es un sistema fácil de usar y esta disponible para todas las plataformas populares, como Linux, Mac OSX y Windows.

La instalación depende de la plataforma, pero generalmente hay paquetes disponibles para instalar con el administrador de paquetes propio de cada sistema.

Por ejemplo, en el caso de Ubuntu o Debian Linux, basta ejecutar el siguiente comando:

$ apt-get install subversion

En el caso de Red Hat o CentOS, el comando es muy similar:

$ yum install subversion

Otras distribuciones de Linux y otros sistemas operativos tienen sus propios mecanismos de instalación, pero no difieren mucho de lo anterior.

Arranque del servidor

Una vez instalado Subversion, puede iniciarse el servicio utilizando el comando :command:`svnserve`, de la siguiente manera:

$ svnserve -d

El servicio espera peticiones en el puerto 3690, por lo que si se tiene un firewall debe abrirse dicho puerto para entrada y salida.

Creación de un repositorio

Por supuesto, el servicio recién iniciado no tiene ninguna utilidad hasta que es creado un repositorio para servir. Esto se hace con el comando :command:`svnadmin`, el cual recibe como parámetro el path dentro del sistema de archivos donde se desea crear el repositorio:

$ svnadmin create /path/del/repositorio

El path puede ser cualquiera en el sistema, pero hay que asegurarse que los usuarios tengan acceso de lectura por lo menos en todo el path elegido. Al crear el repositorio, Subversion genera una serie de directorios dentro del path elegido. Por ejemplo, si creamos el repositorio en /opt/svn:

$ svnadmin create /opt/svn
$ cd /opt/svn
$ ls
conf  db  format  hooks  locks  README.txt

El contenido del repositorio se guarda dentro del directorio db, pero por supuesto nunca hay que modificar nada dentro del mismo.

El repositorio que hemos creado tiene un URL que se forma utilizando el protocolo svn con el host donde se encuentra el servicio de svnserve y el path completo al repositorio. En este caso: svn://localhost/opt/svn.

Configuración de un repositorio

Por el momento, el único directorio que debe interesarnos dentro del repositorio es conf, pues ahí se guardan los archivos de configuración. El archivo principal de configuración de Subversion es svnserve.conf y contiene las siguientes declaraciones, omitiendo los comentarios:

[general]
anon-access = read
auth-access = write
password-db = passwd
authz-db = authz
realm = My First Repository

[sasl]
use-sasl = false
min-encryption = 0
max-encryption = 256

La sección general define primero el tipo de acceso permitido al repositorio. Por defecto, los usuarios anónimos tiene permiso para leer y solo los autenticados pueden escribir. En la mayoría de los ambientes corporativos, es deseable que los usuarios anónimos no tengan ningún acceso, por lo que la declaración correspondiente debe cambiarse por la siguiente:

anon-access = write

Generalmente este es el único cambio que tiene sentido en los valores de acceso.

Las siguientes dos opciones, password-db y authz-db se refieren a nombres de archivos en el mismo directorio que contienen la base de datos de contraseñas y las definiciones de grupos y permisos por path, respectivamente.

La opción realm se utiliza para nombrar al repositorio y puede tener cualquier valor deseado.

Finalmente, la sección sasl es para definir si se desea utilizar cifrado para las contraseñas. En caso de que el valor de use-sasl sea true, el archivo definido arriba en password-db no se utiliza. El uso de SASL requiere tener instalado el soporte para SASL en el sistema.

Base de datos de contraseñas

El archivo passwd contiene la definición de usuarios y contraseñas del repositorio. Es simplemente un archivo de texto donde se define un usuario con su contraseña en cada linea:

[users]
juan = secreto

En el ejemplo, se define un usuario llamado juan, con la contraseña secreto. Para agregar usuarios simplemente hay que poner una nueva linea con el nombre del usuario y la contraseña, separados por el signo =.

Definiciones de grupos y permisos por path

El archivo authz contiene las definiciones de grupos y permisos por path. Por defecto contiene solamente ejemplos:

[aliases]
# joe = /C=XZ/ST=Dessert/L=Snake City/O=Snake, Ltd./OU=Institute/CN=Joe Average

[groups]
# harry_and_sally = harry,sally
# harry_sally_and_joe = harry,sally,&joe

# [/foo/bar]
# harry = rw
# &joe = r
# * =

# [repository:/baz/fuz]
# @harry_and_sally = rw
# * = r

Dado que el repositorio que recién hemos creado no tiene contenido aun, no podemos configurar otro path mas que la raíz. Para permitir al usuario juan que definimos arriba acceso de lectura y escritura al repositorio, basta agregar las siguientes lineas:

[/]
juan = rw

También es posible agregar grupos de usuarios en la sección groups. Basta poner el nombre de grupo y a continuación una lista de nombres de los que fueron definidos en el archivo passwd, separados por comas.

Estructura del repositorio

Una vez creado y configurado el repositorio es importante definir su estructura antes de comenzar a importar contenido. Independientemente de la organización de carpetas que se decida adoptar, en un repositorio de Subversion se recomienda tener una carpeta principal por cada proyecto. A su vez, dentro de cada proyecto es usual utilizar una carpeta con la versión oficial del código, llamada trunk, así como carpetas para etiquetar versiones y para realizar pruebas, llamadas tags y branches respectivamente.

import – Como importar un proyecto

La estructura inicial de directorios puede crearse paso a paso, pero en muchas ocasiones es mejor importarla en un solo paso utilizando ya sea un proyecto ya existente o simplemente una estructura de carpetas. El comando de Subversion para hacer esto se llama :command:`svn import`.

Para importar una estructura de directorios al repositorio que creamos con anterioridad, podemos usar una secuencia de comandos como la que sigue:

$ mkdir proyecto_ejemplo
$ cd proyecto_ejemplo
$ mdkir trunk tags branches
$ cd ..
$ svn import proyecto_ejemplo svn://localhost/opt/svn/proyecto_ejemplo
Adding         proyecto_ejemplo/trunk
Adding         proyecto_ejemplo/branches
Adding         proyecto_ejemplo/tags

Committed revision 1

La primera vez que nos conectamos al repositorio, Subversion nos pedirá la contraseña para entrar, asumiendo que nuestro nombre de usuario es el mismo con el que estamos conectados en nuestro sistema. Si esto no es así, basta presionar la tecla enter sin escribir nada y Subersion nos preguntara el nombre de usuario primero.

Antes de hacer el import, Subversion abrirá una ventana del editor defecto del sistema, para que escribamos un mensaje que explique el cambio. Esto debe hacerse en todas las operaciones de escritura al repositorio y es útil ser concisos pero al mismo tiempo informativos al poner el comentario.

Nótese que al final de la operación, Subversion nos informa el numero de versión que se aplica a estos cambios. Cada operación donde se cambia el repositorio aumenta el numero de versión por uno, independientemente de la cantidad de documentos modificados en ella.

ls – Como listar los contenidos del repositorio

Para verificar que el import funciono correctamente, podemos pedir un listado del contenido de la nueva carpeta en el repositorio, utilizando el comando :command:`svn ls`:

$ svn ls svn://localhost/opt/svn/proyecto_ejemplo
branches/
tags/
trunk/

mkdir – Como crear directorios en el repositorio

Otra manera de crear la estructura del repositorio es creando las carpetas directamente, utilizando el comando:command:`svn mkdir`:

$ svn mkdir svn://localhost/opt/svn/otro_ejemplo -m 'nuevo proyecto'

Committed revision 2

En este caso, en lugar de esperar a que se nos muestre una ventana del editor, enviamos el mensaje junto con el comando utilizando la opción -m. Esto podemos hacerlo con todos los comandos que escriben en el repositorio en lugar de utilizar el editor.

Comandos básicos de Subversion

Una vez que se tiene un proyecto o estructura en el repositorio, la manera de trabajar con Suversion es extraer una copia del proyecto para realizar cambios y subirlos al terminar. Esta copia del proyecto se conoce como copia de trabajo y Subversion puede determinar exactamente que documentos se han agregado o han sido modificados mientras trabajos en ella.

checkout – Como crear una copia de trabajo

El proceso de obtener del repositorio una copia del proyecto se conoce como :command:`svn checkout`. El parámetro que se pasa al comando además del path en el repositorio que queremos copiar es el nombre de la carpeta donde colocaremos la copia:

$ svn co svn://localhost/opt/svn/proyecto_ejemplo proyecto_ejemplo
A    proyecto_ejemplo/trunk
A    proyecto_ejemplo/tags
A    proyecto_ejemplo/branches
Checked out revision 2

Los archivos del proyecto quedan guardados en la carpeta proyecto_ejemplo y Subversion nos informa que la versión que ha obtenido es la 2. Una vez que se ha realizado el checkout podemos cambiarnos al directorio del proyecto y comenzar a trabajar.

info – Como obtener información básica del repositorio

Al cambiarnos dentro del directorio de la copia de trabajo, Subversion puede reconocer que estamos utilizando un repositorio. En cualquier momento podemos obtener los datos del repositorio donde estamos conectados utilizando el comando :command:`svn info`:

$ cd proyecto_ejemplo
$ svn info
Path: .
URL: svn://localhost/opt/svn/proyecto_ejemplo
Repository Root: svn://localhost/opt/svn
Repository UUID: 073e038a-3ebf-4a60-b88a-b0abaccd7367
Revision: 2
Node Kind: directory
Schedule: normal
Last Changed Author: juan
Last Changed Rev: 2
Last Changed Date: 2010-04-09 00:30:57 -0500 (Fri, 09 Apr 2010)

El comando :command:`svn info` nos devuelve entre otras cosas el URL de donde se extrajo el directorio donde estamos trabajando (URL), el URL de la raíz del repositorio (Repository Root), la revision o versión al momento del checkout (Revision), el autor del ultimo cambio (Last Changed Author) y la fecha de ese cambio (Last Changed Date).

status – Como conocer el estado de nuestras modificaciones

Una vez que comenzamos a hacer modificaciones dentro del directorio del proyecto, Subversion lleva la cuenta de los cambios que hemos realizado y en cualquier momento podemos consultarlos:

$ cd trunk
$ echo "La capital de Francia es Tokio" > info.txt
$ svn status
?      info.txt

En el ejemplo anterior, creamos un archivo de texto con una sola linea, llamado info.txt. Una vez creado el archivo, utilizamos el comando :command:`svn status` para mostrar como Subversion ha detectado que existe un nuevo archivo en el directorio. El signo de interrogación que aparece antes del nombre, significa que el archivo en cuestión no esta bajo control de versiones y Subversion lo desconoce.

add – Como agregar documentos al proyecto

Para agregar ese archivo al proyecto, utilizamos el comando :command:`svn add`:

$ svn add info.txt
A      info.txt

Subversion agrega el archivo info.txt a los que se encuentran bajo control de versiones, por lo que el status muestra ahora la letra A junto al nombre. Es importante hacer notar que este comando únicamente tiene efecto en nuestra copia de trabajo y no sube de inmediato el archivo al repositorio.

El comando :command:`svn add` no esta limitado a agregar un solo archivo, por supuesto. Es posible incluir como parámetro cualquier cantidad de archivos. Si se agrega un directorio, todos los archivos contenidos en el serán agregados recursivamente al proyecto.

commit – Como guardar nuestros cambios en el repositorio

Podemos hacer todos los cambios que necesitemos en nuestra copia de trabajo, si bien se recomienda subir la información al menos al final de cada sesión de trabajo y de preferencia cada vez que terminemos una tarea especifica de edición. La razón es que mientras mas tiempo pasemos sin subir los cambios, mas difícil puede resultar integrarlos con otros cambios al repositorio, especialmente si muchas personas tienen acceso al mismo.

A la operación de subir los cambios al repositorio se le llama commit. Una vez que hemos terminado nuestra sesión de trabajo, utilizamos ese comando para guardarlos en el repositorio:

$ svn commit -m 'se agrego archivo info'
Adding         trunk/info.txt
Transmitting file data .
Committed revision 3.

El comando :command:`svn commit` guarda todos los cambios realizados desde que inicio la sesión. En caso de no querer guardar todo, es posible especificar los archivos que deben subirse.

Ciclo de trabajo con Subversion

Para utilizar Subversion eficientemente, la rutina de trabajo que utilizamos debe cambiar un poco para incluir los momentos en que actualizamos o subimos archivos. Ademas, a lo largo del tiempo, el repositorio ira evolucionando y encontraremos necesidad de revisar cambios anteriores y, si trabajamos con otras personas, de resolver conflictos.

Subversion tiene varios comandos para apoyarnos en ese ciclo básico de trabajo. En esta sección conoceremos algunos de los mas importantes.

update – Como trabajar con la versión mas reciente

Lo primero que debemos hacer diariamente al iniciar una sesión de trabajo, es actualizar nuestra copia de trabajo del repositorio, para asegurarnos de trabajar con la versión mas reciente de nuestros documentos. El comando para hacer esto se llama :command:`svn update`:

$ svn update
At revision 3.

El comando actualiza los archivos que han cambiado, integrando al mismo tiempo nuestros cambios y nos muestra el status de lo que ha sido modificado, junto con la versión a la que nos hemos actualizado. En el ejemplo anterior no hubo cambios que integrar.

Ahora supongamos que alguien ha agregado un titulo al archivo info.txt y ha subido sus cambios. Si hacemos un update ahora, veremos la diferencia:

$ svn update
U    trunk/info.txt
Updated to revision 4.

En este caso, Subversion nos muestra el status U, que significa que un documento existente fue modificado.

log – Como revisar la historia de un documento

Como el archivo info.txt ha sido modificado, quizá deseamos saber quien realizo la modificación y cuando. Subversion ofrece el comando :command:`svn log` para poder conocer la historia de commits de un archivo:

$ svn log info.txt
------------------------------------------------------------------------
r4 | predro | 2010-04-09 23:02:29 -0500 (Fri, 09 Apr 2010) | 1 line

se agrego titulo
------------------------------------------------------------------------
r3 | juan | 2010-04-09 22:41:55 -0500 (Fri, 09 Apr 2010) | 1 line

se agrego archivo info
------------------------------------------------------------------------

El comando nos muestra revisión, autor, fecha y comentario por cada cambio que se ha hecho al archivo. En este caso, podemos ver que el usuario pedro agrego un titulo a nuestro archivo.

diff – Como revisar los cambios que hemos realizado en una sesión

Si además de conocer al autor del cambio y su comentario queremos saber exactamente que texto ha cambiado en nuestro archivo, podemos utilizar el comando :command:`svn diff` de Subversion para hacerlo:

$ svn diff -r3:4 info.txt
Index: info.txt
===================================================================
--- info.txt        (revision 3)
+++ info.txt        (revision 4)
@@ -1 +1,3 @@
+Sabia usted que...
+
 La capital de Francia es Tokio

El comando :command:`svn diff` acepta el parámetro -r para especificar los números de versiones entre los que queremos conocer la diferencia. En este caso necesitamos conocer los cambios entre las revisiones 3 y 4, por lo que pasamos esos números. Se puede omitir el parámetro -r y entonces Subversion nos dará las diferencias entre el estado actual del archivo y el estado que tenia la ultima vez que actualizamos el repositorio.

Lo que nos muestra el comando son las lineas que difieren entre una versión y otra. Las lineas que tienen el símbolo + al lado izquierdo son las lineas que fueron agregadas entre la primera y la segunda versión especificadas. En caso de que se hayan eliminado algunas lineas, estas tendrán el símbolo – a su lado izquierdo.

blame – Como saber quien modifico una parte especifica de un documento

Todavía podemos averiguar mas información sobre la historia de cambios del archivo. El comando :command:`svn blame` nos muestra la ultima revisión en que ha cambiado cada linea del archivo, junto con el nombre del autor del cambio:

$ svn blame info.txt
4      pedro Sabia usted que...
4      pedro
3      juan  La capital de Francia es Tokio
Anuncios

Publicado el 16 septiembre, 2014 en Desarrollo de Interfaces. Añade a favoritos el enlace permanente. Comentarios desactivados en DI Desarrollo de Interfaces ..

Los comentarios están cerrados.

A %d blogueros les gusta esto: