svn - tortoise - ¿Puedes hacer un pago parcial con Subversion?

svn merge branch to trunk

Question

Si tuviera 20 directorios en trunk / con muchos archivos en cada uno y solo necesitara 3 de esos directorios, ¿sería posible hacer un pago de Subversion con solo esos 3 directorios en trunk?

Answer 1

De hecho, gracias a los comentarios a mi publicación aquí, parece que los documentation son el camino a seguir. Creo que lo siguiente debería hacerlo:

svn checkout --depth empty http://svnserver/trunk/proj
svn update --set-depth infinity proj/foo
svn update --set-depth infinity proj/bar
svn update --set-depth infinity proj/baz

Alternativamente, --depth immediates lugar de empty comprueba los archivos y directorios en trunk/proj sin sus contenidos. De esta forma, puede ver qué directorios existen en el repositorio.

Como se menciona en la respuesta de @ zigdon, también puede hacer un pago no recursivo. Esta es una forma más antigua y menos flexible de lograr un efecto similar:

svn checkout --non-recursive http://svnserver/trunk/proj
svn update trunk/foo
svn update trunk/bar
svn update trunk/baz

Answer 2

Escribí una secuencia de comandos para automatizar revisiones complejas y dispersas.

#!/usr/bin/env python

''''''
This script makes a sparse checkout of an SVN tree in the current working directory.

Given a list of paths in an SVN repository, it will:
1. Checkout the common root directory
2. Update with depth=empty for intermediate directories
3. Update with depth=infinity for the leaf directories
''''''

import os
import getpass
import pysvn

__author__ = "Karl Ostmo"
__date__ = "July 13, 2011"

# =============================================================================

# XXX The os.path.commonprefix() function does not behave as expected!
# See here: http://mail.python.org/pipermail/python-dev/2002-December/030947.html
# and here: http://nedbatchelder.com/blog/201003/whats_the_point_of_ospathcommonprefix.html
# and here (what ever happened?): http://bugs.python.org/issue400788
from itertools import takewhile
def allnamesequal(name):
    return all(n==name[0] for n in name[1:])

def commonprefix(paths, sep=''/''):
    bydirectorylevels = zip(*[p.split(sep) for p in paths])
    return sep.join(x[0] for x in takewhile(allnamesequal, bydirectorylevels))

# =============================================================================
def getSvnClient(options):

    password = options.svn_password
    if not password:
        password = getpass.getpass(''Enter SVN password for user "%s": '' % options.svn_username)

    client = pysvn.Client()
    client.callback_get_login = lambda realm, username, may_save: (True, options.svn_username, password, True)
    return client

# =============================================================================
def sparse_update_with_feedback(client, new_update_path):
    revision_list = client.update(new_update_path, depth=pysvn.depth.empty)

# =============================================================================
def sparse_checkout(options, client, repo_url, sparse_path, local_checkout_root):

    path_segments = sparse_path.split(os.sep)
    path_segments.reverse()

    # Update the middle path segments
    new_update_path = local_checkout_root
    while len(path_segments) > 1:
        path_segment = path_segments.pop()
        new_update_path = os.path.join(new_update_path, path_segment)
        sparse_update_with_feedback(client, new_update_path)
        if options.verbose:
            print "Added internal node:", path_segment

    # Update the leaf path segment, fully-recursive
    leaf_segment = path_segments.pop()
    new_update_path = os.path.join(new_update_path, leaf_segment)

    if options.verbose:
        print "Will now update with ''recursive'':", new_update_path
    update_revision_list = client.update(new_update_path)

    if options.verbose:
        for revision in update_revision_list:
            print "- Finished updating %s to revision: %d" % (new_update_path, revision.number)

# =============================================================================
def group_sparse_checkout(options, client, repo_url, sparse_path_list, local_checkout_root):

    if not sparse_path_list:
        print "Nothing to do!"
        return

    checkout_path = None
    if len(sparse_path_list) > 1:
        checkout_path = commonprefix(sparse_path_list)
    else:
        checkout_path = sparse_path_list[0].split(os.sep)[0]



    root_checkout_url = os.path.join(repo_url, checkout_path).replace("//", "/")
    revision = client.checkout(root_checkout_url, local_checkout_root, depth=pysvn.depth.empty)

    checkout_path_segments = checkout_path.split(os.sep)
    for sparse_path in sparse_path_list:

        # Remove the leading path segments
        path_segments = sparse_path.split(os.sep)
        start_segment_index = 0
        for i, segment in enumerate(checkout_path_segments):
            if segment == path_segments[i]:
                start_segment_index += 1
            else:
                break

        pruned_path = os.sep.join(path_segments[start_segment_index:])
        sparse_checkout(options, client, repo_url, pruned_path, local_checkout_root)

# =============================================================================
if __name__ == "__main__":

    from optparse import OptionParser
    usage = """%prog  [path2] [more paths...]"""

    default_repo_url = "http://svn.example.com/MyRepository"
    default_checkout_path = "sparse_trunk"

    parser = OptionParser(usage)
    parser.add_option("-r", "--repo_url", type="str", default=default_repo_url, dest="repo_url", help=''Repository URL (default: "%s")'' % default_repo_url)
    parser.add_option("-l", "--local_path", type="str", default=default_checkout_path, dest="local_path", help=''Local checkout path (default: "%s")'' % default_checkout_path)

    default_username = getpass.getuser()
    parser.add_option("-u", "--username", type="str", default=default_username, dest="svn_username", help=''SVN login username (default: "%s")'' % default_username)
    parser.add_option("-p", "--password", type="str", dest="svn_password", help="SVN login password")

    parser.add_option("-v", "--verbose", action="store_true", default=False, dest="verbose", help="Verbose output")
    (options, args) = parser.parse_args()

    client = getSvnClient(options)
    group_sparse_checkout(
        options,
        client,
        options.repo_url,
        map(os.path.relpath, args),
        options.local_path)

Answer 3

Más o menos Como dice Bobby:

svn co file:///.../trunk/foo file:///.../trunk/bar file:///.../trunk/hum

obtendrá las carpetas, pero obtendrá carpetas separadas desde una perspectiva de subversión. Tendrá que ir a commits y actualizaciones por separado en cada subcarpeta.

No creo que pueda verificar un árbol parcial y luego trabajar con el árbol parcial como una sola entidad.

Answer 4

No de ninguna manera especialmente útil, no. Puedes ver los subárboles (como sugiere Bobby Jack), pero luego pierdes la capacidad de actualizarlos / comprometerlos atómicamente; para hacer eso, deben ser colocados bajo su padre común, y tan pronto como revises al padre común, descargarás todo bajo ese padre. No recursivo no es una buena opción, porque quiere que las actualizaciones y los compromisos sean recursivos.

Answer 5

O haga un pago no recursivo de / trunk, luego simplemente haga una actualización manual en los 3 directorios que necesita.

Answer 6

Subversion 1.5 presenta pagos dispersos que pueden ser útiles. De la documentation :

... directorios dispersos (o registros superficiales ) ... le permite ver fácilmente una copia de trabajo, o una parte de una copia de trabajo, más superficialmente que la recursión completa, con la libertad de incluir archivos y subdirectorios previamente ignorados en una tiempo más tarde.