क्या आप सबवर्सन के साथ आंशिक चेकआउट कर सकते हैं?

Question

यदि मेरे पास ट्रंक के तहत 20 निर्देशिकाएं थीं और प्रत्येक में बहुत सारी फाइलें थीं और केवल उन निर्देशिकाओं में से 3 की आवश्यकता थी, तो ट्रंक के तहत केवल 3 निर्देशिकाओं के साथ सबवर्सन चेकआउट करना संभव होगा?

Answer 1

सबवर्सन 1.5 विरल checkouts जो कुछ आपके लिए उपयोगी हो सकता है हो सकता है का परिचय: यह एक समान प्रभाव को प्राप्त करने के लिए एक पुरानी और कम आसान तरीका है। से documentation:

... विरल निर्देशिका (या उथले checkouts) ... की अनुमति देता है आप आसानी से काम कर रहे कॉपी-या पूर्ण प्रत्यावर्तन से कॉपी-अधिक उथले एक काम के एक हिस्से की जाँच करने के लिए , बाद में पहली बार अनदेखी फाइलों और उपनिर्देशिकाओं को लाने की आजादी के साथ।

Answer 2

या गैर-रिकर्सिव चेकआउट/ट्रंक करें, तो बस आपको आवश्यक 3 निर्देशिकाओं पर मैन्युअल अपडेट करें।

Answer 3

किसी विशेष रूप से उपयोगी तरीके से नहीं, नहीं। आप सबट्रीज़ (जैसे बॉबी जैक के सुझाव में) देख सकते हैं, लेकिन फिर आप उन्हें निष्क्रिय रूप से अद्यतन/प्रतिबद्ध करने की क्षमता खो देते हैं; ऐसा करने के लिए, उन्हें अपने सामान्य माता-पिता के अधीन रखा जाना चाहिए, और जैसे ही आप आम माता-पिता की जांच करेंगे, आप उस माता-पिता के तहत सबकुछ डाउनलोड करेंगे। गैर-पुनरावर्ती एक अच्छा विकल्प नहीं है, क्योंकि आप अपडेट चाहते हैं और रिकर्सिव होने के लिए प्रतिबद्ध हैं।

Answer 4

क्रमबद्ध करें। जैसा कि बॉबी कहते हैं:

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

फ़ोल्डर प्राप्त करेंगे, लेकिन आपको एक विवर्तन परिप्रेक्ष्य से अलग फ़ोल्डर्स मिलेंगे। आपको प्रत्येक उपफोल्डर पर अलग-अलग काम और अपडेट जाना होगा।

मुझे विश्वास नहीं है कि आप आंशिक पेड़ की जांच कर सकते हैं और फिर आंशिक पेड़ के साथ एक इकाई के रूप में काम कर सकते हैं।

Answer 5

दरअसल, मेरी पोस्ट पर टिप्पणियों के लिए धन्यवाद, ऐसा लगता है कि sparse directories जाने का तरीका है। मेरा मानना ​​है कि निम्नलिखित यह करना चाहिए:

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 

वैकल्पिक रूप से, उनकी सामग्री के बिना --depth immediatesempty के बजाय चेक trunk/proj में फाइल और निर्देशिका। इस तरह आप देख सकते हैं कि भंडार में कौन सी निर्देशिका मौजूद है।

---

जैसा कि @ ज़िगडन के उत्तर में बताया गया है, आप एक गैर-पुनरावर्ती चेकआउट भी कर सकते हैं।

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

Answer 6

मैंने जटिल स्पैस चेकआउट स्वचालित करने के लिए एक स्क्रिप्ट लिखी।

#!/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)