Tutorials V NR Ioux

2016
GUIA DE
TRABAJO CON
SUBVERSION EN
NETBEANS
[INGENIERA DEL SOFTWARE II

GUA DE SUBVERSION CON
NETBEANS]
Ingeniera del Software II Gua Subversion con Netbeans.
Contenido
Contenido ............................................................................................................................................ 1
CONTROL DE VERSIONES CON SUBVERSION. ..................................................................................... 3
Descripcin General de Subversion .................................................................................................... 3
Primeros pasos: ................................................................................................................................... 4
Repositorio RiuxSVN............................................................................................................................ 5
COMENCEMOS. ............................................................................................................................... 5
Crear un repositorio en RiouxSVN .................................................................................................. 7
Configurar cuenta............................................................................................................................ 8
Crear un nuevo repositorio ............................................................................................................. 8
Crear y administrar nuestro equipo de trabajo. ........................................................................... 13
TortoiseSVN....................................................................................................................................... 17
Descargar el Archivo ejecutable. ................................................................................................... 17
Configurar NetBeans para poder trabajar con subversion. .............................................................. 18
Importar proyecto a nuestro repositorio RiouxSVN ..................................................................... 19
Visualizar versin del proyecto desde RiouxSVN. ......................................................................... 23
Modificar archivo fuente desde Netbeans.................................................................................... 24
Visualizacin de cambios en el editor de cdigo fuente ............................................................... 25
Insignias y cdigo de colores.................................................................................................... 25
Realizar un commit desde Netbeans............................................................................................. 27
La ventana de control de versiones .............................................................................................. 30
Operaciones permitidas ................................................................................................................ 32
Acciones permitidas sobre archivos. ......................................................................................... 33
Crear una rama (branch) en NetBeans......................................................................................... 35
Comparacin de revisiones de archivos ........................................................................................ 37
Prof. Lic. Miguel Angel Recalde Pgina 1

La fusin (merge) de revisiones de archivos ................................................................................. 39
Commitar nuestra fuente a un repositorio. .................................................................................. 41
Actualizacin de copias locales ................................................................................................. 41
Resolucin de conflictos................................................................................................................ 42
Descargar cdigos del repositorio desde NetBeans.......................................................................... 42
Bibliografa. ....................................................................................................................................... 49
Sobre el material. .............................................................................................................................. 49

CONTROL DE VERSIONES CON SUBVERSION.

El control de versiones es fundamental para gestionar los cambios en el software. Por tanto,
disponer de herramientas que automaticen y faciliten este trabajo es de vital importancia.
Subversion es un sistema de control de versiones de software libre. Permite mantener un

repositorio en red, de manera que puede ser accedido remotamente desde mltiples
localizaciones, para ello proporciona herramientas que facilitan la realizacin de backups de los
contenidos del repositorio.
Subversin se encarga de mantener diferentes versiones de cada uno de los elementos software
de un proyecto, sin limitarse nicamente al cdigo fuente, tambien proporciona mecanismos para
facilitar el trabajo colaborativo, que entre otras cosas ayudan a evitar la sobreescritura de
versiones y la consecuente prdida de informacin. Si bien es responsabilidad ltima de los
usuarios controlar estas situaciones. Es importante recordar que Subversion no slo versiona
ficheros, sino tambin carpetas e, incluso, las operaciones de mover y copiar se pueden realizar
sobre unos y otras.
Descripcin General de Subversion

Subversion es un sistema centralizado para compartir informacin. En su ncleo hay un
repositorio, que es un almacn central de datos. El repositorio almacena la informacin en forma
de un rbol de ficheros - una jerarqua tpica de ficheros y directorios. Esta estructura del
repositorio se asemeja bastante a un sistema de ficheros habitual, pero tiene una caracterstica
aadida: este repositorio guarda y registra todos los cambios que se hayan hecho en l a lo largo
del tiempo. Por tanto, se puede acceder a la ltima versin del rbol de ficheros, que en
Subversion se conoce como versin HEAD. Pero tambin se pueden ver estados previos del
repositorio. De hecho, se puede recorrer toda la historia del contenido del repositorio.
En Subversion un repositorio es una secuencia de rboles de directorios. Cada rbol es una imagen
del estado del software versionado en un momento del tiempo. Estas imgenes se llaman
revisiones y son el producto de las operaciones de los participantes en el proyecto que tienen
acceso al repositorio. Cada revisin tiene propiedades que no son versionadas, es decir, si se
modifican se pierde su valor anterior.
Cuando se trabaja con ficheros compartidos, varios usuarios se conectan al repositorio, para
acceder a esos ficheros, ya sea para leer o escribir en ellos. De este modo comparten la
informacin. El problema que puede surgir es, que en un acceso simultneo, mientras un cliente
est actualizando una versin de un fichero, otro est leyendo esa misma versin, pero sin
conocer esa nueva actualizacin. Es decir, distintas personas estn trabajando con distintas
versiones del software, lo que da lugar a problemas e inconsistencias en la informacin.

Existen varios modelos de versionado para resolver este problema. El utilizado por Subversion
consiste en copiar-modificar-fusionar. Cada usuario crea una copia de trabajo personal de un
fichero, una carpeta o de todo el proyecto en la mquina local. Los usuarios trabajan
simultneamente, modificando sus copias privadas. Cuando uno de ellos termina, incorpora sus
modificaciones al repositorio. Cuando, despus, otro usuario intenta incorporar sus cambios,
Subversion le indica que su copia de trabajo est desactualizada (ha cambiado desde que lo
copi).
Este segundo usuario pide entonces a Subversion que fusione cualquier cambio del nuevo
repositorio en su copia de trabajo. Si los cambios no se solapan la tarea es muy sencilla. Pero si los
cambios s se superponen aparece una situacin de conflicto, entonces la fusin se realiza
manualmente al poder observar los cambios existentes en el repositorio y los que el usuario haba
introducido en su copia de trabajo. Resuelto el conflicto se pueden incorporar los cambios en el
repositorio. Normalmente estas situaciones son llamadas colisiones, y aunque manualmente es
posible mezclar varias versiones de un mismo elemento software que fueron creadas en paralelo,
es conveniente prevenir y evitar que esto ocurra. El motivo es que, frecuentemente, los cambios
efectuados son incompatibles y, por tanto, no directamente fusionables, con la consiguiente
prdida de tiempo y de trabajo. Para prevenir estas situaciones es necesario contar con una
correcta planificacin y reparto de tareas.
Cuando se trabaja en red con Subversion, suele existir un repositorio comn en algn servidor y
varios clientes o usuarios que se conectan a travs de la red. En estos casos el funcionamiento o
modelo de red se basa en peticiones y respuestas. Cada usuario pasa la mayor parte del tiempo
manejando copias de trabajo. Cuando necesita informacin de un repositorio, hace una peticin
mediante un acceso a una URL. El servidor le pide que se identifique y, una vez realizada la
autenticacin, el servidor le responde. Es decir, el cliente hace primero la peticin y slo se le
requerir la identificacin si la peticin realizada lo solicita. Si, por ejemplo, el repositorio est
configurado para que todo el mundo pueda leer en l, nunca se pedir autenticacin para una
solicitud de una copia de trabajo en un directorio local.
Si el cliente hace una peticin que implica escribir en el repositorio, como, por ejemplo, confirmar
los cambios realizados, se crea un nuevo rbol de revisin. Si la peticin del cliente ya fue
autenticada, el nombre del usuario identificado se almacena en la variable svn:autor de la nueva
revisin. Si el servidor no pidi la identificacin al cliente, la propiedad svn:autor estar vaca.
Primeros pasos:
El objetivo del presente material es conocer los primeros pasos que hay seguir para trabajar con
Subversion al crear un repositorio dentro de RiuxSVN, este repositorio nos ayudara a guardar
nuestras versiones de codigo creadas durante nuestro de curso de Ingeniera de Software II.

Repositorio RiuxSVN
RiuxSVN es un proyecto que se basa en un equipo de voluntarios compestos por desarrolladores
web y administradores de sistemas. Ofrece el alojamiento de 50 MB gratuito en cuatro
repositorios y el tamao del equipo es ilimitado con cuatro ranuras de recompra por defecto
donde uno puede ir agregando mas espacio en disco y en numero de repositorios mediante la
compra de creditos. Por cada dlar donado equivale a un credito que se puede canjear por 20 MB
y por cada dos dolares donados se puede canjar por un repositorio extra.
COMENCEMOS.
Lo primero que hacemos esingresar al sitio para creanos una cuenta cuenta, para ello nos vamos a
https://riouxsvn.com/login y completamos todos los datos.
Figura 1: Vista para crear una cuenta en riouxsvn
Luego de crear la cuenta nos muestra un mensaje donde se nos comunica que tenemos que
ingresar a nuestra cuenta de correo para activar nuestra cuenta.

Figura 2: Vista del mensaje de Registro completado
Una vez dentro del correo vamos a encontrar el Codigo de activacion y el link que nos lleva a la
ventana de Activacin de Cuenta, es alli donde tenemos que completar los datos solicitados.
Figura 3: Vista del formulario de Activacin de cuenta.

Crear un repositorio en RiouxSVN

Ahora ya estamos en condiciones de ingresar al sitio con nuestro usuario y contrasea.
Figura 4: Vista del formulario de Login.
Una vez dentro podemos comenzar trabajar dentro de ella.
Figura 5: Vista de la pestaa Dashboard.

Configurar cuenta
Vamos a comenzar configurando las opciones personales asociadas a nuestra cuenta, para ello nos
vamos en la pestaa Account.
Figura 6: Vista de los pasos para configurar una cuenta.
Crear un nuevo repositorio

Para crear un nuevo repositorio vamos a la pestaa Dashboard, por el momento no tenemos
creado nuestro repositorio,en este punto podemos observar que el numero de repositorios
activos esta en cero pero por el tipo de cuenta que tenemos podemos crear hasta cuatro
repositorios, entonces vamos a crear el primero, para ello elegimos el boton Create new
repository.

Figura 7: Vista de los pasos a seguir para crear un repositorio.
Este proceso de creacin cuenta con tres pasos, en el primero tenemos que elegir el Ttulo y el
Nombre del repositorio, donde el nombre tiene que estar en minsculas y sin espacios.

Figura 8: Paso 1 para la creacin del repositorio
En el paso dos tenemos que establecer las opciones de importacion de datos, podemos crear el
repositorio desde cero o podemos seleccionar la creacin de los directorios trunk, branch y tags,
para nuestro ejemplo vamos a elegir la segunda opcion.

Figura 9: Paso 2 para la creacin del nuevo repositorio.
En el paso tres si todo va bien podemos observar la creacin del nuevo repositrio, donde tenemos
que confirmar su creacin.
Figura 10: Paso 3 para la creacin del nuevo repositorio.

Esto nos lleva a la pestaa Repositories donde ahora podemos observar el nuevo repositorio
creado
Figura 11: Vista del nuevo repositorio creado.
Ahora seleccionamos el nombre del repositorio, esto nos lleva a la pestaa Activity, donde
podemos observar la URL para nuestro Subversion, la creacin de la estructura del repositorio y el
Repository Team para administrar los miembros del equipo.
Figura 12: Administrar nuevos miembros del equipo

Al seleccionar la revision 1 podemos observar los detalles sobre los cambios que se producen en el
repositorio.
Figura 13: Vista de la estructura del repositorio.
Crear y administrar nuestro equipo de trabajo.

RiouxSVN nos permite trabajar con un equipo de desarrollo asociado a nuestro repositorio, para
crear nuestro equipo nos vams hata la pestaa User y una vez alli para agregar un miembro al
equipo de desarrollo hacemos clic en Add new user.

Figura 14: Pasos para agregar nuevos usuarios.
Nuevamente este procedimiento cuenta con tres etapas.
La primera es introducir el Nombre de usuario a agregar, luego hacemos clic en el boton Search.
Figura 15: Paso 1 - Buscar nombre de usuario.
En el paso dos tenemos que seleccionar el nombre de usuario y elegimos el botn Next step.

Figura 16: Paso 2 - Seleccionar nombre de usuario.
En el tercer paso tenemos que seleccionar el nombre del repositorio y los permisos de acceso,
luego agregamos el usuario con Add User.
Figura 17: Paso 3 - Seleccionar nombre de repositorio y asignar permisos.

Ahora podemos observar el nuevo usuario agregado.
Figura 18: Vista del nuevo usuario agregado.
Es aqu donde nosotros podemos eliminar al nuevo usuario o tambin podemos editar para
cambiar los permisos otorgados a un miembro del equipo, tambin se podemos establecer
permisos para cada uno de los repositorios.
Figura 19: Vista de las opciones disponibles para administrar usuarios.

TortoiseSVN
Bien para poder trabajar desde Netbean utilizando Subversion primero necesitamos instalar en
local el software Subversion, para ello nos vamos a la pagina TortoiseSVN
https://tortoisesvn.net/downloads.html
Figura 20: Vista de la pgina TortoiseSVN
Descargar el Archivo ejecutable.

Aqu vamos a elegir descargar el instalador segn nuestro sistema operativo, podemos descargar
las versiones para 32 o 64 bits. Esto nos lleva a la ventana de descarga
Figura 21: Vista de la descarga para Windows.

Luego instalamos el software siguiendo todos los pasos necesarios.
Configurar NetBeans para poder trabajar con subversion.

Ahora vamos hasta NetBeans donde tenemos que hacer algunas modificaciones en el men
Herramientas > Opciones.
Figura 22: Configurar complementos.
Luego en la pestaa Plugins disponibles elegimos la opcion Busqueda buscamos Bundled

Suversion dentro de ella Subversion, luego en la Ruta al archivo ejecutable de SVN tenemos que
pasarle la ruta donde esta instalado nuestro ejecutable, en mi caso esta en C:\Program
Files\TortoiseSVN\bin\TortoiseMerge.exe .
Tambin en esta ventana podemos agregar ciertas variables como revisin y configurar otras
opciones.

Figura 23: Seleccin del plugin a utilizar desde NetBeans.
Seleccionamos el boton Instalar, esto nos lleva a la ventana Intalador de Netbeans donde tenemos
que Aceptar los terminos de la licencia, esta instalacin dependiendo de nuestra conexin puede
tardar un poco, lugo al finalizar la instalacin tenemos que reiniciar el IDE para que nos tome los
cambios.
Importar proyecto a nuestro repositorio RiouxSVN

Para importar nuestro proyecto nos posicionamos sobre el nombre del proyecto, clic derecho y
elegimos la opcin Control de versiones => Importar al repositorio Subversion.

Figura 24: Pasos para importar un proyecto a un repositorio.
Esto nos lleva a la ventana de Import donde tenemos que pegar en Repository URL la url que nos
gener en el riouxsvn, la direccin que le tenemos que pasar debe ser de la siguiente forma
https://svn.riouxsvn.com/trunk/nombre del proyecto, en User se coloca el nombre de usuario y en
Password el password creado en el riouxsvn. Si estamos trabajando dentro de una red es muy
importante completar la Configuracin Proxy y completar los datos de usuario y contrasea de la
red. En esta ventana importar completamos la URL que nos gener riouxsnv que para nuestro
ejemplo es https://svn.riouxsvn.com/pl-svn

Figura 25: Paso 1 - Importar proyecto al Repositorio de Subversion
En el siguiente paso completamos la ruta que nos falta trunk/nombre del proyecto.
Presionamos el botn Siguiente para pasar al siguiente paso, all podemos observar el nombre del
Repositorio de carpeta donde se observa el nombre del proyecto.
Figura 26: Paso 2 - Importar a Carpeta de repositorio.
Lo ms importante en este paso es Especificar el mensaje, es recomendable siempre poner en el

mensaje los cambios que vamos haciendo en nuestro proyecto, esto es para tener un mejor
control. Presionamos el botn Siguiente y pasamos al tercer paso.
Este proceso puede tardar algunos minutos dependiendo del tamao del proyecto.
Figura 27: Importando datos del proyecto al repositorio remoto.
Luego aparece el paso tres Archivos a Importar.
Figura 28: Paso 3 Confirmar los archivos a importar.

En este punto aparece la lista de todos los archivos que vamos a importar o a commitar al servidor
de RiouxSVN, presionamos el botn Terminar.
Visualizar versin del proyecto desde RiouxSVN.

Ahora de vuelta nos vamos nuevamente a RiouxSVNdonde esta nuestro proyecto.
Dentro del proyecto en riouxSVN podemos observar en la pestaa Activity en la opcin Activity
Stream la revisin 3 de nuestro proyecto.
Figura 29: Vista de la versin del proyecto - Pestaa Activity.
Ahora podemos observar nuestro mensaje y una lista de los cambios hechos en el archivo.

Figura 30: Vista del mensaje y los cambios realizados a los archivos.
Si elegimos uno de los archivos guardados en el repositorio podemos acceder a su contenido
Modificar archivo fuente desde Netbeans

Ahora qu pasa si nosotros hacemos modificaciones en nuestro cdigo dentro de Netbeans?.

Figura 31: Vista de los cdigos modificados y comentarios agregados.
Visualizacin de cambios en el editor de cdigo fuente

Al abrir un archivo versionado en el Editor del IDE, se pueden ver los cambios que se producen en
el archivo en tiempo real. A medida que trabaja, el IDE utiliza la codificacin de color en los
mrgenes del editor de cdigo fuente para transmitir la siguiente informacin:
azul ( ) Indica lneas que han sido modificados desde la revisin anterior.
Verde ( ) Indica lneas que se han agregado desde la revisin anterior.
Rojo ( ) Indica lneas que han sido eliminados desde la revisin anterior.
Ahora el IDE nos muestra que hay nuevas lneas de cdigos o que la fuente ha sido cambiada,
ahora nos vamos a la pestaa Proyectos y vemos unos pequeos iconos cilndricos de color azul,
esto nos indica que este cdigo no est actualizado con el servidor de RiouxSVN.
Insignias y cdigo de colores

Insignias se aplican al proyecto, carpeta y nodos del paquete y nos informan del estado de los
archivos contenidos dentro de ese nodo:

La siguiente tabla muestra el esquema de color que se utiliza:

Componente IU Descripcin
Indica la presencia de archivos que han sido modificados localmente, agregados o

eliminados. Para los paquetes, esta placa se aplica nicamente al paquete en s y no a
Blue Badge ( )
sus sub-paquetes. Para los proyectos o carpetas, el smbolo de identificacin indica
cambios dentro de ese elemento, o cualquiera de las subcarpetas contenidas.
Marca proyectos, carpetas o paquetes que contengan archivos en conflicto (es decir,
las versiones locales que entran en conflicto con las versiones que se mantienen en el
Red Badge ( ) repositorio). Para los paquetes, esta placa se aplica nicamente a la caja en s y no a
sus sub-paquetes. Para los proyectos o carpetas, el smbolo de identificacin indica
conflictos dentro de ese elemento, o cualquiera de las subcarpetas contenidas.
El cdigo de colores se aplica a los nombres de archivo con el fin de indicar su estado actual en el repositorio:
Color Ejemplo Descripcin
Azul Indica que el archivo se ha modificado localmente.
Verde Indica que el archivo ha sido aadido a nivel local.
Indica que el archivo contiene los conflictos entre su copia

rojo
de trabajo local y la versin del repositorio.
Indica que el archivo es ignorado por la subversin y no se

incluye en versiones de comandos (por ejemplo,
Gris
actualizacin y Commit). Los archivos slo se pueden hacer
para ser ignorado si an no han sido versionado.
Indica que el archivo est excluido de las operaciones de

commit del texto tachado aparece solamente en lugares
especficos, como la ventana de dilogo de versiones o
Atravesamiento Commit, cuando se elige para excluir archivos individuales
de una accin de confirmacin. Tales archivos an se ven
afectados por otros comandos de Subversion, como
actualizacin.

Figura 32: Vista de pestaa proyectos donde se observan cambios al archivo modificado desde Netbeans.
Figura 33: Vista de los iconos generados.
Realizar un commit desde Netbeans

Entonces vamos a enviar este nuevo cambio, para ello hacemos clic derecho sobre el Nombre del
proyecto => Subversion => Confirmar (Commit ) para enviar este nuevo cambio.

Figura 34: Vista del nuevo commit.
Ahora esto nos lleva a la ventana de Commit, ac es muy importante completar el Commit
Message.
Figura 35: Ventana Commit - Completar el Commit mensaje y seleccin de archivo a confirmar.

Ahora presionamos el botn Confirmar.
Ahora podemos ver en nuestro IDE que ya no nos marca en Paquetes de fuentes el Icono de color
azul.
Figura 36: Vista del archivo commitado sin los iconos.
Ahora nos vamos a nuestro proyecto de RIouxSVN y vemos los cambios, el numero 4 nos indica
que es la revisin 4, tambin nos muestra el comentario que escribimos.
Figura 37: Vista de la revisin 4 dentro de la pestaa Activity.
Ahora vemos la nueva versin r4 con el cambio realizado desde Netbeans.

Hacemos clic sobre rev4 y esto nos lleva a la siguiente ventana donde me muestra cual fue el
archivo modificado.
Figura 38: Vista del nombre del archivo modificado.
La ventana de control de versiones

La ventana de control de versiones Subversion nos proporciona una lista en tiempo real de todos
los cambios realizados en los archivos dentro de una carpeta seleccionada de su copia de trabajo
local. Se abre por defecto en el panel inferior de la IDE, el listado aadir, eliminar o modificar los
archivos.
Para abrir la ventana de control de versiones, debemos seleccionar un archivo o una carpeta
versionada (por ejemplo, de los proyectos, archivos) y, o bien optar desde el men por Equipo >
Subversion> Mostrar cambios o hacer clic derecho sobre el archivo y elegimos Subversion >
Mostrar cambios.

Tabla 1: Pasos a seguir para mostrar cambios en Subversion
La siguiente ventana aparece en la parte inferior de la IDE:
Figura 39: Vista de la ventana Subversion
Por defecto, la ventana de versiones muestra una lista de todos los archivos modificados dentro
del paquete o carpeta seleccionada. Usando los botones en la barra de herramientas, podemos
optar por mostrar todos los cambios o limitar la lista de los archivos para que nos muestre los
archivos modificados de forma local o remota. Tambin podemos hacer clic en los encabezados de

columna por encima de los archivos de la lista para ordenar los archivos por nombre, estado o
ubicacin.
Operaciones permitidas
Con la ventana de versiones, hacemos clic en el botn Actualizar estado.
Las operaciones en la ventana de proyectos trabajan slo en los propios proyectos y no son
recursivas. Para mostrar modificaciones en los proyectos anidado / hijo, podemos utilizar la
ventana de Archivos o Favoritos.
La barra de herramientas de la ventana de versiones tambin incluye botones que permiten

invocar las tareas ms comunes de Subversion en todos los archivos mostrados en la lista. La
siguiente tabla muestra los comandos de Subversion disponibles en la barra de herramientas de la
ventana de control de versiones:
Icono Nombre Funcin
Actualiza el estado de los archivos y carpetas seleccionados. Los

archivos que se muestran en la ventana de versiones pueden
Actualizar estado
actualizarse para reflejar los cambios que se hayan podido realizar
externamente.
Se abre el visor de diferencias que le proporciona una comparacin

Comparar Todo (Diff all) lado a lado de las copias locales y las versiones mantenidas en el
repositorio.
Actualizar todo Actualiza todos los archivos seleccionados desde el repositorio.
Confirmar todo
Permite confirmar los cambios locales en el repositorio.
Commit all
Tabla 2: Herramientas disponibles en la ventana Subversion
Tambin podemos acceder a otros comandos de Subversion en la ventana de control de

versiones mediante la seleccin de una fila de la tabla que corresponde a un archivo modificado, y
la eleccin de un comando del men contextual:

Acciones permitidas sobre archivos.

Acciones Ejemplos
Mostrar anotaciones:
Muestra informacin del autor y nmero de

revisin en el margen izquierdo de archivos
abiertos en el editor de cdigo fuente.
Buscar Historial:
Nos permite buscar y comparar mltiples

revisiones del archivo seleccionado en el Visor
de Historia de la IDE. En el Visor de Historia
tambin se puede realizar un diff o revertir su
copia local a una revisin seleccionada.
Excluir de Modificacin (Commit):

Permite marcar el archivo que se excluir al

realizar un commit.
Deshacer borrado:
Abre el dilogo revierte las modificaciones,

lo que le permite revertir cualquier accin
de borrado que se han comprometido a
archivos en su copia de trabajo local. El
archivo (s) especificado se recupera del
archivo de la historia local del IDE y
reinstalado en su copia de trabajo local.

Revertir Modificaciones:
Abre el dilogo revierte las modificaciones

que se puede utilizar para especificar
parmetros para revertir cualquier cambio
local a la versin que se mantienen en el
repositorio.
Al especificar las revisiones, puede hacer

clic en Buscar para abrir el cuadro de
dilogo de bsqueda Revisiones. Este
explora el repositorio y enumera todas las
revisiones de archivos basados en la fecha
especificada.
Tabla 3: Acciones permitidas sobre los archivos.
Crear una rama (branch) en NetBeans

Las ramas permiten aislar cambios en una lnea separada de desarrollo. Las ramas se utilizan a
menudo para probar nuevas caractersticas sin molestar la lnea principal del desarrollo con
errores de compilacin y errores. Tan pronto como la nueva caracterstica es lo suficiente estable,
la rama de desarrollo se fusiona de nuevo en la rama principal (trunk, troncal/tronco).
Para crear una rama hacemos click derecho en el nombre de nuestro proyecto, se abre el men,
seleccionamos Subversion-> Copiar a.

Figura 40: Pasos para realizar una copia
Se nos abre una ventana en la que aparece una opcin llamada "Fuente", seleccionamos "Carpeta
remota" para que haga el branch de la versin que hay en el servidor porque sino lo har de la
versin de nuestro disco duro. Aqui tenemos que asegurarnos de que hemos hecho un commit de
los ltimos cambios si es que los queremos incluir en el nuevo branch.
Ahora, en el apartado "Destino", en "Ubicacin de repositorio" debemos indicar la ruta dentro de

nuestro repositorio donde queremos el branch. Para darle un nombre al branch, podemos escribir
en el cuadro de texto directamente o tambin podemos hacer click en el botn "Examinar"->"A
una carpeta, y darle el nombre al directorio del branch.
Si queremos podemos seleccionar la opcin "Cambiar a copia" y nuestro proyecto en local estar
apuntando al nuevo branch.

Figura 41: Vista de los pasos a seguir para crear un branch.
Comparacin de revisiones de archivos

Al comparar las revisiones de archivos es una tarea comn cuando se trabaja con proyectos
versionados. El IDE nos permite comparar las revisiones con el comando diff, que est disponible
en el men del botn derecho de un elemento seleccionado (Subversion -> Diferencia o
Subversion -> Diff), as como de la ventana de control de versiones. En la ventana de control de
versiones, puede realizar diferenciaciones haciendo doble clic en un archivo de la lista, de lo
contrario puede hacer clic en el icono Comparar todo (Diff All) situado en la barra de
herramientas en la parte superior.
Al realizar un Comparar (diff), una grfica de Visor de diferencias se abre para el archivo
seleccionado (s) y revisiones en la ventana principal del IDE. El visor de diferencias muestra dos
copias en los paneles de lado a lado. La copia ms actual aparece en el lado derecho, por lo que si
usted est comparando una revisin de repositorio en contra de su copia de trabajo, la copia de
trabajo se muestra en el panel derecho:

Figura 42: Vista de las diferencias que existen entre las copias.
El visor de diferencias hace uso de la misma codificacin de color utilizado en otro lugar para
mostrar los cambios de control de versiones. En la captura de pantalla que se muestra arriba, el
bloque verde indica el contenido que ha sido aadido a la revisin ms actual. El bloque rojo indica
que el contenido de la revisin anterior se ha eliminado de la anterior. El color azul indica que los
cambios se han producido dentro de la lnea (s) resaltado.
Adems, al realizar un comparar (diff) en un grupo de archivos, como por ejemplo en un

proyecto, un paquete o carpeta, o al hacer clic en Comparar todo (Diff All ), podemos
cambiar entre las diferenciaciones haciendo clic en los archivos que figuran en la zona superior del
visor de diferencias.
El visor de diferencias tambin nos proporciona las siguientes funcionalidades:

Funcionalidad Iconos de Funcionalidad
Realizar cambios en su copia de trabajo local Sustituir ( ): Inserta el texto resaltado de la

Si vamos a realizar un comparar (diff) en revisin anterior a la revisin actual
nuestra copia de trabajo local, el IDE nos
permite realizar cambios directamente desde el Mover todo ( ): Revierte la versin actual
visor de diferencias. Para ello, podemos colocar del archivo en el estado de la revisin anterior
el cursor en el panel derecho del visor de seleccionada.
diferencias y modificar el archivo
Eliminar ( ): Elimina el texto resaltado de la
correspondiente o hacemos uso de los iconos
revisin actual de forma que refleja la revisin
que se muestran en lnea junto a cada cambio
anterior.
de puesto de relieve:
Navegar por las diferencias entre los archivos Anterior ( ): Va a diferencia anterior se
comparados muestra en el diff
Si nuestro compara (diff) contiene varias
diferencias, se podemos navegar entre ellos Siguiente ( ): Va a la siguiente diferencia
mediante el uso de los iconos de las flechas que que aparece en el diff.
aparecen en la barra de herramientas. Los
iconos de flecha nos permiten ver las
diferencias tal como aparecen de arriba a
abajo:
Cambiar Criterios de Visualizacin. local ( ): Slo muestra los archivos

Si deseamos podemos elegir ver los archivos modificados localmente.
que contienen los cambios de la copia de
trabajo local, el repositorio, as como ambos a remoto ( ): Slo muestra los archivos
la vez: de forma remota modificados.
Ambos ( ): Muestra tanto local como

remotamente archivos modificados.
Tabla 4: Funcionalidades del visor de diferencias.
La fusin (merge) de revisiones de archivos

El IDE de NetBeans nos permite combinar los cambios entre revisiones del repositorio y nuestra
copia de trabajo local. Se puede especificar un rango de revisiones para la fusin (merge).
Podemos incluso combinar un rango de revisiones a partir de dos carpetas separadas del
repositorio.

El siguiente escenario describe un caso de uso comn: Ha desprotegido la versin trunk en una
carpeta con el nombre ejemploJUnitJdoc , y ahora quiere fusionar su copia con una rama
(branch). Para fines demostrativos, nuestro diseo del repositorio contiene una carpeta branches
utilizada para contener todos los archivos ramificados:
1. En Proyectos, Archivos o en la ventana, hacemos clic en los archivos o carpetas en las que
deseamos realizar la operacin de combinacin (Merge) y seleccione Subversion>
Combinar cambios. El cuadro de dilogo Combinar cambios (Merge).
Figura 43: Pasos a seguir para Combinar cambios.
2. En Combinar cambios (Merge) en la lista desplegable, seleccionamos la carpeta de un

repositorio desde su origen. Nosotros estamos portando todos los cambios realizados en
una sola rama desde el momento en que fue creada.
3. En el campo de texto carpeta de repositorio, introducimos la ruta de la carpeta de la que
deseamos que los cambios de puerto (branches/JavaApp ). Dejamos el campo Revisin de
Finalizacin vaco para indicar que desea incluir todas las revisiones hasta
la cabeza HEAD(es decir, estado actual).

Figura 44: Pasos para realizar un merge.
4. Hacemos clic en Combinar (Merge). El IDE incorpora las diferencias encontradas entre las
revisiones de rama y su copia local del archivo. Si se producen conflictos de fusin, el estado del
archivo se actualiza al conflicto de fusin para indicar esto.
Nota: Despus de la fusin de las revisiones a nuestra copia de trabajo local, an tenemos que
confirmar los cambios utilizando el orden Confirmar (commit) con el fin de que sean aadidos al
repositorio.
Commitar nuestra fuente a un repositorio.

Tras realizar cambios en las fuentes, hay que enviar los cambios al repositorio. Es generalmente
una buena idea para actualizar todas las copias que tenga en contra del repositorio antes de
realizar una confirmacin con el fin de garantizar que no surjan conflictos. Sin embargo se pueden
producir conflictos, y debe ser considerado como un evento natural cuando numerosos
desarrolladores estn trabajando en un proyecto de forma simultnea. El IDE proporciona apoyo
flexible que le permite realizar todas estas funciones. Tambin proporciona un solucionador de
conflictos que nos permite manejar de manera segura los conflictos que se producen.
Actualizacin de copias locales

Podemos realizar actualizaciones eligiendo Subversion> Actualizar en el men contextual de
cualquier tem versionado en los proyectos, archivos o ventanas. Al trabajar directamente desde la
ventana de control de versiones, slo es necesario haga clic derecho en un archivo de la lista y
seleccionamos Actualizar.

Para llevar a cabo una actualizacin de todos los archivos de origen, podemos hacer clic en el
icono Actualizar todo ( ), Que muestra en las barras de herramientas situadas en la parte
superior tanto de la ventana de versiones, as como el visor de diferencias . Cualquier cambio que
pueda haber ocurrido en el repositorio se muestra en la ventana de salida de versiones.
Los conflictos que surgen se deben resolver antes de Commit archivos al repositorio. Podemos
resolver conflictos en el IDE utilizando el (Merge) Combinar conflictos . El Resolver los conflictos
de fusin proporciona una interfaz intuitiva que nos permite abordar los conflictos individuales
secuencialmente mientras se visualiza la salida resultante de la fusin cuando realizamos cambios.
Podemos acceder a la Resolver los conflictos de fusin en un archivo que est en conflicto
haciendo clic derecho en el archivo y elegir la Subversin> Resolver los conflictos.
El Resolver los conflictos de fusin muestra las dos revisiones en conflicto de lado a lado en el
panel superior, con las reas en conflicto resaltados. El panel inferior muestra el archivo tal como
aparece mientras se funde para los conflictos individuales entre las dos revisiones se producen.
Resolucin de conflictos
Al realizar una actualizacin o una confirmacin, el apoyo subversin de la IDE se compara con los
archivos de fuentes de repositorio para asegurarse de que otros cambios no han ocurrido ya en los
mismos lugares. Cuando el proceso checkout previo (o actualizacin) ya no coincide con el HEAD
del repositorio (la revisin ms actual), y los cambios que se aplican en nuestra copia local de
trabajo coinciden con reas en el HEAD, que tambin han cambiado, nuestro Actualizar (Update) o
confirmar (Commit ) resulta en un conflicto.
Como se indica en distintivos y Codificacin de colores, los conflictos se muestran en el IDE con el
texto rojo y se acompaan de una insignia roja. Cuando se ve en los proyectos, archivos o
ventanas. Cuando se trabaja en la ventana de control de versiones, los conflictos tambin son
indicados por el estado de un archivo.
Descargar cdigos del repositorio desde NetBeans.

Ahora vamos a proceder a descargar ese cdigo a travs de NetBeans, vamos a suponer que su
compaero les envi el cdigo para compartir con ustedes su proyecto que est en riouxSVN,
para ello el compaero por ejemplo les enva este cdigo https://svn.riouxsvn.com/pl-svn
Ahora en NetBeans nos vamos en el men Equipo y elegimos Verificar (Checkout).

Figura 45: Para a seguir para realizar un Checkout.
Ahora nos muestra la ventana de Verificar (Checkout) donde hay que seguir varios pasos
En Repository URL: tienen que pegar la url que les pas el compaero.
User y Password lo podemos dejar en blanco si queremos hacer un acceso annimo,

desmarcamos la opcin Save user name and password, luego presionamos el botn Siguiente.
Figura 46: Paso 1 - Especificar URL del repositorio Subversion.
Esto nos lleva a al segundo paso de la ventana Checkout donde tenemos que elegir el Repository
Folder, lo vamos a buscar y para ello seleccionamos Importar. Esto nos lleva a la ventana de
Examinar carpetas del repositorio, luego seleccionamos Aceptar.

Figura 47: Seleccionar el proyecto a importar.
Figura 48: Vista del proyecto seleccionado desde la carpeta del repositorio.
Para nuestro caso es el trunk/ejemploJUnitJdoc y en Revisin del repositorio podemos buscar la

lista de revisiones y seleccionar de ella la revisin que necesitemos.

Figura 49: Lista de las revisiones guardadas en el repositorio remoto.
Para el ejemplo no usaremos la revisin 4 sino que pondremos directamente HEAD para poder
tener la ltima versin.
Figura 50: Vista de las opciones seleccionadas para la importacin.

Seleccionamos Omitir trunk y revisar solo su contenido, podrimos por ejemplo presionar el
botn Examinar y lo bajamos en escritorio, tambin seleccionamos Escanear en busca de
proyectos de NetBeans despus de la revisin, por ultimo presionamos el botn Terminar.
Figura 51: Vista de la ventana Verificacin completada.
Una vez terminado la el Checkout aparece una ventana donde nos muestra la cantidad de
proyectos verificados y nos pregunta si queremos abrir el proyecto que se encontr, entonces
presionamos el botn Abrir Proyecto.
Figura 52: Vista del proyecto a ser abierto en NetBeans.

Es en esta ventana donde elegimos el nombre de nuestro proyecto y finalmente elegimos el botn
Abrir.
Figura 53: Vista del nuevo proyecto descargado.
Es as de fcil traer a Netbeans el cdigo del compaero, ahora podemos ejecutar el proyecto sin
ningn problema.
Figura 54: Vista de la ejecucin del proyecto.

Algo que tener en cuenta ac es que si hacemos cambios en el cdigo, esos cambios solo van a ser
local porque nosotros bajamos el archivo de forma annima y no lo vamos a poder enviar como lo
hicimos antes.
Entonces qu es lo recomendable hacer en estos casos?, con el rol de usuario administrador

como vimos antes puede agregar a otros usuarios y asignarles los permisos correspondientes para
que puedan hacer modificaciones.

Bibliografa.
-Daniel Bolaos Alonso; Almudena Sierra Alonso; Miren Idoia Alarcn Rodrguez.: Pruebas de
software y junit, Pearson Prentice Hall - 2007, Cap. 4 y 5.
-Collins-Sussman, B.; Fitzpatrick, B. W. y Pilato, C. M.: Version Control with Subversion,
2006. http://svnbook.red-bean.com/nightly/en/svn-book.pdf
-Kng, S., Onken, L. y Large, S.: TortoiseSVN. Un cliente de Subversion para Windows,
Versin 1.4.1. 2006
-http://gerardobarcia.com/blog/?p=6
-https://riouxsvn.com/
Sobre el material.
Todos los datos utilizados para la creacin del repositorio son ficticios y con fines ilustrativos
acadmicos nicamente. De ninguna manera se pretende que este documento sea una plantilla
final.
Nuevamente el documento aqu presentado es solo un ejemplo, su contenido pretende servir

solamente como orientacin y apoyo a los conceptos presentados en clase presencial, que se ha
de aplicar con sentido comn y con arreglo a las particularidades del contexto de que se trate.

Tutorials V NR Ioux

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Tutorials V NR Ioux

Încărcat de

Drepturi de autor:

Formate disponibile

2016

[INGENIERA DEL SOFTWARE II

CONTROL DE VERSIONES CON SUBVERSION. ..................................................................................... 3

Descripcin General de Subversion .................................................................................................... 3

Primeros pasos: ................................................................................................................................... 4

Crear un repositorio en RiouxSVN .................................................................................................. 7

Crear un nuevo repositorio ............................................................................................................. 8

Crear y administrar nuestro equipo de trabajo. ........................................................................... 13

Descargar el Archivo ejecutable. ................................................................................................... 17

Configurar NetBeans para poder trabajar con subversion. .............................................................. 18

Importar proyecto a nuestro repositorio RiouxSVN ..................................................................... 19

Visualizar versin del proyecto desde RiouxSVN. ......................................................................... 23

Modificar archivo fuente desde Netbeans.................................................................................... 24

Visualizacin de cambios en el editor de cdigo fuente ............................................................... 25

Insignias y cdigo de colores.................................................................................................... 25

Realizar un commit desde Netbeans............................................................................................. 27

La ventana de control de versiones .............................................................................................. 30

Operaciones permitidas ................................................................................................................ 32

Acciones permitidas sobre archivos. ......................................................................................... 33

Crear una rama (branch) en NetBeans......................................................................................... 35

Comparacin de revisiones de archivos ........................................................................................ 37

Prof. Lic. Miguel Angel Recalde Pgina 1

La fusin (merge) de revisiones de archivos ................................................................................. 39

Commitar nuestra fuente a un repositorio. .................................................................................. 41

Actualizacin de copias locales ................................................................................................. 41

Descargar cdigos del repositorio desde NetBeans.......................................................................... 42

Sobre el material. .............................................................................................................................. 49

Prof. Lic. Miguel Angel Recalde Pgina 2

CONTROL DE VERSIONES CON SUBVERSION.

Subversion es un sistema de control de versiones de software libre. Permite mantener un

Descripcin General de Subversion

Prof. Lic. Miguel Angel Recalde Pgina 3

Prof. Lic. Miguel Angel Recalde Pgina 4

Figura 1: Vista para crear una cuenta en riouxsvn

Prof. Lic. Miguel Angel Recalde Pgina 5

Figura 2: Vista del mensaje de Registro completado

Figura 3: Vista del formulario de Activacin de cuenta.

Prof. Lic. Miguel Angel Recalde Pgina 6

Crear un repositorio en RiouxSVN

Figura 4: Vista del formulario de Login.

Una vez dentro podemos comenzar trabajar dentro de ella.

Figura 5: Vista de la pestaa Dashboard.

Prof. Lic. Miguel Angel Recalde Pgina 7

Figura 6: Vista de los pasos para configurar una cuenta.

Crear un nuevo repositorio

Prof. Lic. Miguel Angel Recalde Pgina 8

Figura 7: Vista de los pasos a seguir para crear un repositorio.

Prof. Lic. Miguel Angel Recalde Pgina 9

Figura 8: Paso 1 para la creacin del repositorio

Prof. Lic. Miguel Angel Recalde Pgina 10

Figura 9: Paso 2 para la creacin del nuevo repositorio.

Figura 10: Paso 3 para la creacin del nuevo repositorio.

Prof. Lic. Miguel Angel Recalde Pgina 11

Figura 11: Vista del nuevo repositorio creado.

Figura 12: Administrar nuevos miembros del equipo

Prof. Lic. Miguel Angel Recalde Pgina 12

Figura 13: Vista de la estructura del repositorio.

Crear y administrar nuestro equipo de trabajo.

Prof. Lic. Miguel Angel Recalde Pgina 13

Figura 14: Pasos para agregar nuevos usuarios.

Nuevamente este procedimiento cuenta con tres etapas.

Figura 15: Paso 1 - Buscar nombre de usuario.

Prof. Lic. Miguel Angel Recalde Pgina 14