Changeset 527 in tailor


Ignore:
Timestamp:
08/09/05 01:36:47 (8 years ago)
Author:
lele@…
Hash name:
20050808233647-97f81-c2b161feb61fde0d387d466b1710dc661e822899
Message:

Big API change, reducing arguments in favour of instance attributes
This is a big and subtle change that brings nothing in term of
functionality but make it a lot easier maintaining and extending
tailor as a whole.

Basically, 'root' and 'subdir' arguments are gone replaced by a
self.basedir, computed from the configuration; instead of 'logger',
the code uses two new methods, log_info() and log_error() on most
objects. Other arguments are derived from the configuration objects
that hang around.

Location:
vcpx
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • vcpx/cvsps.py

    r515 r527  
    138138    ## UpdatableSourceWorkingDir 
    139139 
    140     def _getUpstreamChangesets(self, root, repository, module, sincerev=None, 
    141                               branch=None): 
     140    def _getUpstreamChangesets(self, sincerev=None): 
    142141        from os.path import join, exists 
    143142 
    144         if branch is None: 
    145             branch="HEAD" 
    146             fname = join(root, 'CVS', 'Tag') 
    147             if exists(fname): 
    148                 tag = open(fname).read() 
    149                 if tag.startswith('T'): 
    150                     branch=tag[1:-1] 
     143        branch="HEAD" 
     144        fname = join(self.basedir, 'CVS', 'Tag') 
     145        if exists(fname): 
     146            tag = open(fname).read() 
     147            if tag.startswith('T'): 
     148                branch=tag[1:-1] 
    151149 
    152150        if sincerev: 
    … …  
    155153        changesets = [] 
    156154        cmd = [self.repository.CVSPS_CMD, "--cvs-direct", "-u", "-b", branch, 
    157                "--root", repository] 
     155               "--root", self.repository.repository] 
    158156        cvsps = ExternalCommand(command=cmd) 
    159         log = cvsps.execute(module, stdout=PIPE, TZ='UTC') 
     157        log = cvsps.execute(self.repository.module, stdout=PIPE, TZ='UTC') 
    160158 
    161159        for cs in changesets_from_cvsps(log, sincerev): 
    … …  
    164162        return changesets 
    165163 
    166     def __maybeDeleteDirectory(self, root, entrydir, changeset): 
     164    def __maybeDeleteDirectory(self, entrydir, changeset): 
    167165        from os.path import join, exists 
    168166        from os import listdir 
    … …  
    171169            return 
    172170 
    173         absentrydir = join(root, entrydir) 
     171        absentrydir = join(self.basedir, entrydir) 
    174172        if not exists(absentrydir) or listdir(absentrydir) == ['CVS']: 
    175173            deldir = changeset.addEntry(entrydir, None) 
    176174            deldir.action_kind = deldir.DELETED 
    177175 
    178     def _applyChangeset(self, root, changeset, logger=None): 
     176    def _applyChangeset(self, changeset): 
    179177        from os.path import join, exists, dirname, split 
    180178        from os import makedirs, listdir 
    … …  
    183181        from time import sleep 
    184182 
    185         entries = CvsEntries(root) 
     183        entries = CvsEntries(self.basedir) 
    186184 
    187185        for e in changeset.entries: 
    … …  
    189187                info = entries.getFileInfo(e.name) 
    190188                if not info: 
    191                     if logger: logger.info("promoting '%s' to ADDED at " 
    192                                            "revision %s", e.name, 
    193                                            e.new_revision) 
     189                    self.log_info("promoting '%s' to ADDED at " 
     190                                  "revision %s", e.name, e.new_revision) 
    194191                    e.action_kind = e.ADDED 
    195                     self.__createParentCVSDirectories(changeset, root, e.name) 
     192                    self.__createParentCVSDirectories(changeset, e.name) 
    196193                elif info.cvs_version == e.new_revision: 
    197                     if logger: logger.debug("skipping '%s' since it's already " 
    198                                             "at revision %s", e.name, 
    199                                             e.new_revision) 
     194                    self.log_info("skipping '%s' since it's already " 
     195                                  "at revision %s", e.name, e.new_revision) 
    200196                    continue 
    201197            elif e.action_kind == e.DELETED: 
    202                 if not exists(join(root, e.name)): 
    203                     if logger: logger.debug("skipping '%s' since it's already " 
    204                                             "deleted", e.name) 
    205                     self.__maybeDeleteDirectory(root, split(e.name)[0], 
    206                                                 changeset) 
     198                if not exists(join(self.basedir, e.name)): 
     199                    self.log_info("skipping '%s' since it's already " 
     200                                  "deleted", e.name) 
     201                    self.__maybeDeleteDirectory(split(e.name)[0], changeset) 
    207202                    continue 
    208203            elif e.action_kind == e.ADDED and e.new_revision is None: 
    … …  
    218213 
    219214            if e.action_kind == e.DELETED and e.new_revision is None: 
    220                 assert listdir(join(root, e.name)) == ['CVS'], '%s should be empty' % e.name 
    221                 rmtree(join(root, e.name)) 
     215                assert listdir(join(self.basedir, e.name)) == ['CVS'], '%s should be empty' % e.name 
     216                rmtree(join(self.basedir, e.name)) 
    222217            else: 
    223218                cmd = [self.repository.CVS_CMD, "-q", "update", "-d", "-r", e.new_revision] 
    224                 cvsup = ExternalCommand(cwd=root, command=cmd) 
     219                cvsup = ExternalCommand(cwd=self.basedir, command=cmd) 
    225220                retry = 0 
    226221                while True: 
    … …  
    232227                            break 
    233228                        delay = 2**retry 
    234                         if logger: 
    235                             logger.warning("%s returned status %s, " 
    236                                            "retrying in %d seconds..." % 
    237                                            (str(cvsup), cvsup.exit_status, 
    238                                             delay)) 
     229                        self.log_info("%s returned status %s, " 
     230                                      "retrying in %d seconds..." % 
     231                                      (str(cvsup), cvsup.exit_status, 
     232                                       delay)) 
    239233                        sleep(retry) 
    240234                    else: 
    … …  
    246240                                                   cvsup.exit_status)) 
    247241 
    248                 if logger: logger.info("%s updated to %s" % (e.name, 
    249                                                              e.new_revision)) 
     242                self.log_info("%s updated to %s" % (e.name, e.new_revision)) 
    250243 
    251244            if e.action_kind == e.DELETED: 
    252                 self.__maybeDeleteDirectory(root, split(e.name)[0], changeset) 
    253  
    254     def _checkoutUpstreamRevision(self, basedir, repository, module, revision, 
    255                                   subdir=None, logger=None, **kwargs): 
     245                self.__maybeDeleteDirectory(split(e.name)[0], changeset) 
     246 
     247    def _checkoutUpstreamRevision(self, revision): 
    256248        """ 
    257249        Concretely do the checkout of the upstream sources. Use `revision` as 
    … …  
    279271                revision, timestamp = revision.split(' ', 1) 
    280272 
    281         wdir = join(basedir, subdir) 
    282         csets = self._getUpstreamChangesets(wdir, repository, module, 
    283                                            branch=revision or 'HEAD') 
     273        csets = self._getUpstreamChangesets(revision) 
    284274        csets.reverse() 
    285275 
    … …  
    287277            timestamp = csets[-1].date.isoformat(sep=' ') 
    288278 
    289         if not exists(join(wdir, 'CVS')): 
     279        if not exists(join(self.basedir, 'CVS')): 
    290280            cmd = [self.repository.CVS_CMD, "-q", "-d", repository, "checkout", 
    291                    "-d", subdir] 
     281                   "-d", self.basedir] 
    292282            if revision: 
    293283                cmd.extend(["-r", revision]) 
    … …  
    295285                cmd.extend(["-D", "%s UTC" % timestamp]) 
    296286 
    297             checkout = ExternalCommand(cwd=basedir, command=cmd) 
     287            checkout = ExternalCommand(command=cmd) 
    298288            checkout.execute(module) 
    299289 
    … …  
    303293                                               checkout.exit_status)) 
    304294        else: 
    305             if logger: logger.info("Using existing %s", wdir) 
    306  
    307         self.__forceTagOnEachEntry(wdir) 
     295            self.log_info("Using existing %s", self.basedir) 
     296 
     297        self.__forceTagOnEachEntry(self.basedir) 
    308298 
    309299        entries = CvsEntries(wdir) 
    … …  
    331321                "revision of the checked out tree in '%s'" % wdir) 
    332322        else: 
    333             if logger: logger.info("working copy up to cvsps revision %s", 
    334                                    last.revision) 
     323            self.log_info("working copy up to cvsps revision %s", last.revision) 
    335324 
    336325        return last 
    337326 
    338     def _willApplyChangeset(self, root, changeset, applyable=None): 
     327    def _willApplyChangeset(self, changeset, applyable=None): 
    339328        """ 
    340329        This gets called just before applying each changeset. 
    … …  
    344333        """ 
    345334 
    346         if UpdatableSourceWorkingDir._willApplyChangeset(self, root, changeset, 
     335        if UpdatableSourceWorkingDir._willApplyChangeset(self, changeset, 
    347336                                                         applyable): 
    348337            for m in changeset.entries: 
    349338                if m.action_kind == m.ADDED: 
    350                     self.__createParentCVSDirectories(changeset, root, m.name) 
     339                    self.__createParentCVSDirectories(changeset, m.name) 
    351340 
    352341            return True 
    … …  
    354343            return False 
    355344 
    356     def __createParentCVSDirectories(self, changeset, root, entry): 
     345    def __createParentCVSDirectories(self, changeset, entry): 
    357346        """ 
    358347        Verify that the hierarchy down to the entry is under CVS. 
    … …  
    368357        path = split(entry)[0] 
    369358        if path: 
    370             basedir = join(root, path) 
     359            basedir = join(self.basedir, path) 
    371360        else: 
    372             basedir = root 
     361            basedir = self.basedir 
    373362        cvsarea = join(basedir, 'CVS') 
    374363 
    375364        if path and not exists(cvsarea): 
    376             parentcvs = self.__createParentCVSDirectories(changeset, 
    377                                                           root, path) 
     365            parentcvs = self.__createParentCVSDirectories(changeset, path) 
    378366 
    379367            assert exists(parentcvs), "Uhm, strange things happen" 
    … …  
    415403    ## SyncronizableTargetWorkingDir 
    416404 
    417     def _addPathnames(self, root, names): 
     405    def _addPathnames(self, names): 
    418406        """ 
    419407        Add some new filesystem objects. 
    … …  
    421409 
    422410        cmd = [self.repository.CVS_CMD, "-q", "add"] 
    423         ExternalCommand(cwd=root, command=cmd).execute(names) 
    424  
    425     def __forceTagOnEachEntry(self, root): 
     411        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
     412 
     413    def __forceTagOnEachEntry(self): 
    426414        """ 
    427415        Massage each CVS/Entries file, locking (ie, tagging) each 
    … …  
    435423        from os.path import join 
    436424 
    437         for dir, subdirs, files in walk(root): 
     425        for dir, subdirs, files in walk(self.basedir): 
    438426            if dir[-3:] == 'CVS': 
    439427                efn = join(dir, 'Entries') 
    … …  
    470458        return entries 
    471459 
    472     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     460    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    473461        """ 
    474462        Commit the changeset. 
    … …  
    499487            entries = ['.'] 
    500488 
    501         ExternalCommand(cwd=root, command=cmd).execute(entries) 
    502  
    503     def _removePathnames(self, root, names): 
     489        ExternalCommand(cwd=self.basedir, command=cmd).execute(entries) 
     490 
     491    def _removePathnames(self, names): 
    504492        """ 
    505493        Remove some filesystem objects. 
    … …  
    507495 
    508496        cmd = [self.repository.CVS_CMD, "-q", "remove"] 
    509         ExternalCommand(cwd=root, command=cmd).execute(names) 
    510  
    511     def _renamePathname(self, root, oldname, newname): 
     497        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
     498 
     499    def _renamePathname(self, oldname, newname): 
    512500        """ 
    513501        Rename a filesystem object. 
    514502        """ 
    515503 
    516         self._removePathnames(root, [oldname]) 
    517         self._addPathnames(root, [newname]) 
     504        self._removePathnames([oldname]) 
     505        self._addPathnames([newname]) 

  • vcpx/source.py

    r516 r527  
    6363        self.state_file = state_file 
    6464 
    65     def applyPendingChangesets(self, root, module, applyable=None, 
    66                                replayable=None, replay=None, applied=None, 
    67                                logger=None): 
     65    def applyPendingChangesets(self, applyable=None, replayable=None, 
     66                               replay=None, applied=None): 
    6867        """ 
    6968        Apply the collected upstream changes. 
    … …  
    8988        remaining = self.pending[:] 
    9089        for c in self.pending: 
    91             if not self._willApplyChangeset(root, c, applyable): 
     90            if not self._willApplyChangeset(c, applyable): 
    9291                break 
    9392 
    94             if logger: 
    95                 logger.info("Applying changeset %s", c.revision) 
     93            self.log_info("Applying changeset %s" % c.revision) 
    9694 
    9795            try: 
    98                 res = self._applyChangeset(root, c, logger=logger) 
     96                res = self._applyChangeset(c) 
    9997            except: 
    100                 if logger: 
    101                     logger.critical("Couldn't apply changeset %s", 
    102                                     c.revision, exc_info=True) 
    103                     logger.debug(str(c)) 
     98                self.log_error("Couldn't apply changeset %s" % c.revision, 
     99                               exc=True) 
    104100                raise 
    105101 
    … …  
    109105                    raw_input(CONFLICTS_PROMPT % (str(c), '\n * '.join(res))) 
    110106                except KeyboardInterrupt: 
    111                     if logger: logger.info("INTERRUPTED BY THE USER!") 
     107                    self.log_info("INTERRUPTED BY THE USER!") 
    112108                    return last, conflicts 
    113109 
    114             if not self._didApplyChangeset(root, c, replayable): 
     110            if not self._didApplyChangeset(c, replayable): 
    115111                continue 
    116112 
    117113            if replay: 
    118                 replay(root, module, c, logger=logger) 
     114                replay(c) 
    119115 
    120116            remaining.remove(c) 
    … …  
    122118 
    123119            if applied: 
    124                 applied(root, c) 
     120                applied(c) 
    125121 
    126122            last = c 
    … …  
    129125        return last, conflicts 
    130126 
    131     def _willApplyChangeset(self, root, changeset, applyable=None): 
     127    def _willApplyChangeset(self, changeset, applyable=None): 
    132128        """ 
    133129        This gets called just before applying each changeset.  The whole 
    … …  
    139135 
    140136        if applyable: 
    141             return applyable(root, changeset) 
     137            return applyable(changeset) 
    142138        else: 
    143139            return True 
    144140 
    145     def _didApplyChangeset(self, root, changeset, replayable=None): 
     141    def _didApplyChangeset(self, changeset, replayable=None): 
    146142        """ 
    147143        This gets called right after changeset application.  The final 
    … …  
    154150 
    155151        if replayable: 
    156             return replayable(root, changeset) 
     152            return replayable(changeset) 
    157153        else: 
    158154            return True 
    159155 
    160     def getPendingChangesets(self,  root, repository, module): 
     156    def getPendingChangesets(self): 
    161157        """ 
    162158        Load the pending changesets from the state file, or query the 
    … …  
    166162        revision, self.pending = self.state_file.load() 
    167163        if not self.pending: 
    168             self.pending = self._getUpstreamChangesets(root, repository, module, 
    169                                                        revision) 
     164            self.pending = self._getUpstreamChangesets(revision) 
    170165        return self.pending 
    171166 
    172     def _getUpstreamChangesets(self, root, repository, module, sincerev): 
     167    def _getUpstreamChangesets(self, sincerev): 
    173168        """ 
    174169        Query the upstream repository about what happened on the 
    … …  
    181176        raise "%s should override this method" % self.__class__ 
    182177 
    183     def _applyChangeset(self, root, changeset, logger=None): 
     178    def _applyChangeset(self, changeset): 
    184179        """ 
    185180        Do the actual work of applying the changeset to the working copy. 
    … …  
    192187        raise "%s should override this method" % self.__class__ 
    193188 
    194     def checkoutUpstreamRevision(self, root, repository, module, revision, 
    195                                  **kwargs): 
    196         """ 
    197         Extract a working copy from a repository. 
    198  
    199         :root: the name of the directory (that **must** exists) 
    200                that will contain the working copy of the sources under the 
    201                *module* subdirectory 
    202  
    203         :repository: the address of the repository (the format depends on 
    204                      the actual method used by the subclass) 
    205  
    206         :module: the name of the module to extract 
    207  
    208         :revision: extract that revision/branch 
     189    def checkoutUpstreamRevision(self, revision): 
     190        """ 
     191        Extract a working copy of the given revision from a repository. 
    209192 
    210193        Return the last applied changeset. 
    211194        """ 
    212195 
    213         if not root: 
    214             raise InvocationError("Must specify a root directory") 
    215         if not repository: 
    216             raise InvocationError("Must specify an upstream repository") 
    217  
    218         last = self._checkoutUpstreamRevision(root, repository, 
    219                                               module, revision, 
    220                                               **kwargs) 
     196        last = self._checkoutUpstreamRevision(revision) 
    221197        self.state_file.write(last.revision, None) 
    222198 
    223199        return last 
    224200 
    225     def _checkoutUpstreamRevision(self, basedir, repository, module, revision, 
    226                                   subdir=None, logger=None, **kwargs): 
     201    def _checkoutUpstreamRevision(self, revision): 
    227202        """ 
    228203        Concretely do the checkout of the upstream revision. 

  • vcpx/target.py

    r517 r527  
    6060    """ 
    6161 
    62     def replayChangeset(self, root, module, changeset, logger=None): 
     62    def replayChangeset(self, changeset): 
    6363        """ 
    6464        Do whatever is needed to replay the changes under the target 
    … …  
    6868 
    6969        try: 
    70             self._replayChangeset(root, changeset, logger) 
     70            self._replayChangeset(changeset) 
    7171        except: 
    72             if logger: logger.critical(str(changeset)) 
     72            self.log_error(str(changeset), exc=True) 
    7373            raise 
    7474 
    … …  
    9696            changelog = changeset.log 
    9797        entries = self._getCommitEntries(changeset) 
    98         self._commit(root, changeset.date, changeset.author, 
     98        self._commit(changeset.date, changeset.author, 
    9999                     patchname, changelog, entries) 
    100100 
    … …  
    106106        return [e.name for e in changeset.entries] 
    107107 
    108     def _replayChangeset(self, root, changeset, logger): 
     108    def _replayChangeset(self, changeset): 
    109109        """ 
    110110        Replicate the actions performed by the changeset on the tree of 
    … …  
    128128        # Replay the actions 
    129129 
    130         if renamed: self._renameEntries(root, renamed) 
    131         if removed: self._removeEntries(root, removed) 
    132         if added: self._addEntries(root, added) 
     130        if renamed: self._renameEntries(renamed) 
     131        if removed: self._removeEntries(removed) 
     132        if added: self._addEntries(added) 
    133133 
    134134        # Finally, deal with "copied" directories. The simple way is 
    … …  
    138138        while added: 
    139139            subdir = added.pop(0).name 
    140             if isdir(join(root, subdir)): 
    141                 self._addSubtree(root, subdir) 
     140            if isdir(join(self.basedir, subdir)): 
     141                self._addSubtree(subdir) 
    142142                added = [e for e in added if not e.name.startswith(subdir)] 
    143143 
    144     def _addEntries(self, root, entries): 
     144    def _addEntries(self, entries): 
    145145        """ 
    146146        Add a sequence of entries 
    147147        """ 
    148148 
    149         self._addPathnames(root, [e.name for e in entries]) 
    150  
    151     def _addPathnames(self, root, names): 
     149        self._addPathnames([e.name for e in entries]) 
     150 
     151    def _addPathnames(self, names): 
    152152        """ 
    153153        Add some new filesystem objects. 
    … …  
    156156        raise "%s should override this method" % self.__class__ 
    157157 
    158     def _addSubtree(self, root, subdir): 
     158    def _addSubtree(self, subdir): 
    159159        """ 
    160160        Add a whole subtree. 
    … …  
    173173        from dualwd import IGNORED_METADIRS 
    174174 
    175         if subdir<>'.': 
    176             self._addPathnames(root, [subdir]) 
    177  
    178         for dir, subdirs, files in walk(join(root, subdir)): 
     175        if subdir and subdir<>'.': 
     176            self._addPathnames([subdir]) 
     177 
     178        for dir, subdirs, files in walk(join(self.basedir, subdir)): 
    179179            for excd in IGNORED_METADIRS: 
    180180                if excd in subdirs: 
    … …  
    187187 
    188188            if subdirs or files: 
    189                 self._addPathnames(dir, subdirs + files) 
    190  
    191     def _commit(self, root, date, author, patchname, 
    192                 changelog=None, entries=None): 
     189                self._addPathnames([join(dir, df)[len(self.basedir)+1:] 
     190                                    for df in subdirs + files]) 
     191 
     192    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    193193        """ 
    194194        Commit the changeset. 
    … …  
    197197        raise "%s should override this method" % self.__class__ 
    198198 
    199     def _removeEntries(self, root, entries): 
     199    def _removeEntries(self, entries): 
    200200        """ 
    201201        Remove a sequence of entries. 
    202202        """ 
    203203 
    204         self._removePathnames(root, [e.name for e in entries]) 
    205  
    206     def _removePathnames(self, root, names): 
     204        self._removePathnames([e.name for e in entries]) 
     205 
     206    def _removePathnames(self, names): 
    207207        """ 
    208208        Remove some filesystem object. 
    … …  
    211211        raise "%s should override this method" % self.__class__ 
    212212 
    213     def _renameEntries(self, root, entries): 
     213    def _renameEntries(self, entries): 
    214214        """ 
    215215        Rename a sequence of entries, adding all the parent directories 
    … …  
    230230            if parents: 
    231231                parents.reverse() 
    232                 self._addPathnames(root, parents) 
    233  
    234             self._renamePathname(root, e.old_name, e.name) 
    235  
    236     def _renamePathname(self, root, oldname, newname): 
     232                self._addPathnames(parents) 
     233 
     234            self._renamePathname(e.old_name, e.name) 
     235 
     236    def _renamePathname(self, oldname, newname): 
    237237        """ 
    238238        Rename a filesystem object to some other name/location. 
    … …  
    241241        raise "%s should override this method" % self.__class__ 
    242242 
    243     def prepareWorkingDirectory(self, root, target_repository, target_module): 
     243    def prepareWorkingDirectory(self): 
    244244        """ 
    245245        Do anything required to setup the hosting working directory. 
    246246        """ 
    247247 
    248         if target_repository: 
    249             self._prepareTargetRepository(root, target_repository, 
    250                                           target_module) 
    251             self._prepareWorkingDirectory(root, target_repository, 
    252                                           target_module) 
    253  
    254     def _prepareTargetRepository(self, root, target_repository, target_module): 
     248        if self.repository.repository: 
     249            self._prepareTargetRepository() 
     250            self._prepareWorkingDirectory() 
     251 
     252    def _prepareTargetRepository(self): 
    255253        """ 
    256254        Possibly create the repository, when overriden by subclasses. 
    257255        """ 
    258256 
    259     def _prepareWorkingDirectory(self, root, target_repository, target_module): 
     257    def _prepareWorkingDirectory(self): 
    260258        """ 
    261259        Possibly checkout a working copy of the target VC, that will host the 
    … …  
    263261        """ 
    264262 
    265     def initializeNewWorkingDir(self, root, source_repository, 
    266                                 source_module, subdir, changeset, initial): 
     263    def initializeNewWorkingDir(self, source_repo, changeset, initial): 
    267264        """ 
    268265        Initialize a new working directory, just extracted from 
    … …  
    270267        """ 
    271268 
    272         self._initializeWorkingDir(root, source_repository, source_module, 
    273                                    subdir) 
     269        self._initializeWorkingDir() 
    274270        revision = changeset.revision 
     271        source_repository = source_repo.repository 
     272        source_module = source_repo.module 
    275273        if initial: 
    276274            author = changeset.author 
    … …  
    281279            patchname = BOOTSTRAP_PATCHNAME % source_module 
    282280            log = BOOTSTRAP_CHANGELOG % locals() 
    283         self._commit(root, changeset.date, author, patchname, log, 
    284                      entries=[subdir]) 
    285  
    286     def _initializeWorkingDir(self, root, source_repository, source_module, 
    287                               subdir): 
    288         """ 
    289         Assuming the ``root`` directory contains a working copy ``module`` 
     281        self._commit(changeset.date, author, patchname, log) 
     282 
     283    def _initializeWorkingDir(self): 
     284        """ 
     285        Assuming the ``basedir`` directory contains a working copy ``module`` 
    290286        extracted from some VC repository, add it and all its content 
    291287        to the target repository. 
    … …  
    296292        """ 
    297293 
    298         self._addSubtree(root, subdir) 
     294        self._addSubtree('.') 

  • vcpx/darcs.py

    r526 r527  
    133133    ## UpdatableSourceWorkingDir 
    134134 
    135     def _getUpstreamChangesets(self, root, repository, module, sincerev=None): 
     135    def _getUpstreamChangesets(self, sincerev): 
    136136        """ 
    137137        Do the actual work of fetching the upstream changeset. 
    … …  
    143143 
    144144        cmd = [self.repository.DARCS_CMD, "pull", "--dry-run"] 
    145         pull = ExternalCommand(cwd=root, command=cmd) 
    146         output = pull.execute(repository, stdout=PIPE, stderr=STDOUT, TZ='UTC') 
     145        pull = ExternalCommand(cwd=self.basedir, command=cmd) 
     146        output = pull.execute(self.repository.repository, 
     147                              stdout=PIPE, stderr=STDOUT, TZ='UTC') 
    147148 
    148149        if pull.exit_status: 
    … …  
    196197        return changesets 
    197198 
    198     def _applyChangeset(self, root, changeset, logger=None): 
     199    def _applyChangeset(self, changeset): 
    199200        """ 
    200201        Do the actual work of applying the changeset to the working copy. 
    … …  
    214215 
    215216        cmd = [self.repository.DARCS_CMD, "pull", "--all", selector, revtag] 
    216         pull = ExternalCommand(cwd=root, command=cmd) 
     217        pull = ExternalCommand(cwd=self.basedir, command=cmd) 
    217218        output = pull.execute(stdout=PIPE, stderr=STDOUT) 
    218219 
    … …  
    224225        cmd = [self.repository.DARCS_CMD, "changes", selector, revtag, 
    225226               "--xml-output", "--summ"] 
    226         changes = ExternalCommand(cwd=root, command=cmd) 
     227        changes = ExternalCommand(cwd=self.basedir, command=cmd) 
    227228        last = changesets_from_darcschanges(changes.execute(stdout=PIPE)) 
    228229        if last: 
    229230            changeset.entries.extend(last[0].entries) 
    230231 
    231     def _checkoutUpstreamRevision(self, basedir, repository, module, revision, 
    232                                   subdir=None, logger=None, **kwargs): 
     232    def _checkoutUpstreamRevision(self, revision): 
    233233        """ 
    234234        Concretely do the checkout of the upstream revision and return 
    … …  
    243243            initial = True 
    244244            cmd = [self.repository.DARCS_CMD, "changes", "--xml-output", 
    245                    "--repo", repository] 
     245                   "--repo", self.repository.repository] 
    246246            changes = ExternalCommand(command=cmd) 
    247247            output = changes.execute(stdout=PIPE, stderr=STDOUT) 
    … …  
    261261            initial = False 
    262262 
    263         wdir = join(basedir, subdir) 
    264         if subdir == '.': 
     263        if self.repository.subdir == '.': 
    265264            # This is currently *very* slow, compared to the darcs get 
    266265            # below! 
    267             if not exists(join(wdir, '_darcs')): 
    268                 if not exists(wdir): 
    269                     mkdir(wdir) 
    270  
    271                 init = ExternalCommand(cwd=wdir, 
     266            if not exists(join(self.basedir, '_darcs')): 
     267                if not exists(self.basedir): 
     268                    mkdir(self.basedir) 
     269 
     270                init = ExternalCommand(cwd=self.basedir, 
    272271                                       command=[self.repository.DARCS_CMD, 
    273272                                                "initialize"]) 
    … …  
    281280                cmd = [self.repository.DARCS_CMD, "pull", "--all", "--verbose"] 
    282281                if revision and revision<>'HEAD': 
    283                     cmd.extend([initial and "--patches" or "--tags", revision]) 
    284                 dpull = ExternalCommand(cwd=wdir, command=cmd) 
    285                 output = dpull.execute(repository, stdout=PIPE, stderr=STDOUT) 
     282                    cmd.extend([initial and "--match" or "--tags", revision]) 
     283                dpull = ExternalCommand(cwd=self.basedir, command=cmd) 
     284                output = dpull.execute(self.repository.repository, 
     285                                       stdout=PIPE, stderr=STDOUT) 
    286286 
    287287                if dpull.exit_status: 
    … …  
    294294            if revision and revision<>'HEAD': 
    295295                cmd.extend([initial and "--to-patch" or "--tag", revision]) 
    296             dget = ExternalCommand(cwd=basedir, command=cmd) 
    297             output = dget.execute(repository, subdir, 
     296            dget = ExternalCommand(command=cmd) 
     297            output = dget.execute(self.repository.repository, self.basedir, 
    298298                                  stdout=PIPE, stderr=STDOUT) 
    299299 
    … …  
    305305        cmd = [self.repository.DARCS_CMD, "changes", "--last", "1", 
    306306               "--xml-output"] 
    307         changes = ExternalCommand(cwd=wdir, command=cmd) 
     307        changes = ExternalCommand(cwd=self.basedir, command=cmd) 
    308308        output = changes.execute(stdout=PIPE, stderr=STDOUT) 
    309309 
    … …  
    320320    ## SyncronizableTargetWorkingDir 
    321321 
    322     def _addPathnames(self, root, names): 
     322    def _addPathnames(self, names): 
    323323        """ 
    324324        Add some new filesystems objects. 
    … …  
    327327        cmd = [self.repository.DARCS_CMD, "add", "--case-ok", 
    328328               "--not-recursive", "--quiet"] 
    329         ExternalCommand(cwd=root, command=cmd).execute(names) 
    330  
    331     def _addSubtree(self, root, subdir): 
     329        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
     330 
     331    def _addSubtree(self, subdir): 
    332332        """ 
    333333        Use the --recursive variant of ``darcs add`` to add a subtree. 
    … …  
    336336        cmd = [self.repository.DARCS_CMD, "add", "--case-ok", "--recursive", 
    337337               "--quiet"] 
    338         ExternalCommand(cwd=root, command=cmd).execute(subdir) 
    339  
    340     def _commit(self, root, date, author, patchname, changelog=None, entries=None): 
     338        ExternalCommand(cwd=self.basedir, command=cmd).execute(subdir) 
     339 
     340    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    341341        """ 
    342342        Commit the changeset. 
    … …  
    359359            entries = ['.'] 
    360360 
    361         record = ExternalCommand(cwd=root, command=cmd) 
     361        record = ExternalCommand(cwd=self.basedir, command=cmd) 
    362362        record.execute(entries, input='\n'.join(logmessage), stdout=PIPE) 
    363363 
    … …  
    366366                "%s returned status %d" % (str(record), record.exit_status)) 
    367367 
    368     def _removePathnames(self, root, names): 
     368    def _removePathnames(self, names): 
    369369        """ 
    370370        Remove some filesystem object. 
    … …  
    374374        # darcs will do the right thing with it, do nothing here, instead 
    375375        # of 
    376         #         c = ExternalCommand(cwd=root, 
     376        #         c = ExternalCommand(cwd=self.basedir, 
    377377        #                             command=[self.repository.DARCS_CMD, 
    378378        #                                      "remove"]) 
    … …  
    382382        pass 
    383383 
    384     def _renamePathname(self, root, oldname, newname): 
     384    def _renamePathname(self, oldname, newname): 
    385385        """ 
    386386        Rename a filesystem object. 
    … …  
    397397        # finally restore its name. 
    398398 
    399         renamed = exists(join(root, oldname)) 
     399        renamed = exists(join(self.basedir, oldname)) 
    400400        if renamed: 
    401401            rename(oldname, oldname + '-TAILOR-HACKED-TEMP-NAME') 
    … …  
    403403        try: 
    404404            cmd = [self.repository.DARCS_CMD, "mv"] 
    405             ExternalCommand(cwd=root, command=cmd).execute(oldname, newname) 
     405            ExternalCommand(cwd=self.basedir, command=cmd).execute(oldname, 
     406                                                                   newname) 
    406407        finally: 
    407408            if renamed: 
    408409                rename(oldname + '-TAILOR-HACKED-TEMP-NAME', oldname) 
    409410 
    410     def _initializeWorkingDir(self, root, source_repository, source_module, 
    411                               subdir): 
     411    def _initializeWorkingDir(self): 
    412412        """ 
    413413        Execute ``darcs initialize`` and tweak the default settings of 
    … …  
    419419        from dualwd import IGNORED_METADIRS 
    420420 
    421         init = ExternalCommand(cwd=root, command=[self.repository.DARCS_CMD, 
    422                                                   "initialize"]) 
     421        init = ExternalCommand(cwd=self.basedir, 
     422                               command=[self.repository.DARCS_CMD, 
     423                                        "initialize"]) 
    423424        init.execute(stdout=PIPE) 
    424425 
    … …  
    427428                "%s returned status %s" % (str(init), init.exit_status)) 
    428429 
    429         motd = open(join(root, '_darcs/prefs/motd'), 'w') 
     430        motd = open(join(self.basedir, '_darcs/prefs/motd'), 'w') 
    430431        motd.write(MOTD % (source_repository, source_module)) 
    431432        motd.close() 
    432433 
    433434        # Remove .cvsignore from default boring file 
    434         boring = open(join(root, '_darcs/prefs/boring'), 'r') 
     435        boring = open(join(self.basedir, '_darcs/prefs/boring'), 'r') 
    435436        ignored = [line for line in boring if line <> '\.cvsignore$\n'] 
    436437        boring.close() 
    … …  
    438439        # Augment the boring file, that contains a regexp per line 
    439440        # with all known VCs metadirs to be skipped. 
    440         boring = open(join(root, '_darcs/prefs/boring'), 'w') 
     441        boring = open(join(self.basedir, '_darcs/prefs/boring'), 'w') 
    441442        boring.write(''.join(ignored)) 
    442443        boring.write('\n'.join(['(^|/)%s($|/)' % escape(md) 
    … …  
    445446        boring.close() 
    446447 
    447         SyncronizableTargetWorkingDir._initializeWorkingDir(self, root, 
    448                                                             source_repository, 
    449                                                             source_module, 
    450                                                             subdir) 
     448        SyncronizableTargetWorkingDir._initializeWorkingDir(self) 

  • vcpx/svn.py

    r515 r527  
    173173    ## UpdatableSourceWorkingDir 
    174174 
    175     def _getUpstreamChangesets(self, root, repository, module, sincerev=None): 
     175    def _getUpstreamChangesets(self, sincerev=None): 
    176176        if sincerev: 
    177177            sincerev = int(sincerev) 
    … …  
    181181        cmd = [self.repository.SVN_CMD, "log", "--verbose", "--xml", 
    182182               "--revision", "%d:HEAD" % (sincerev+1)] 
    183         svnlog = ExternalCommand(cwd=root, command=cmd) 
     183        svnlog = ExternalCommand(cwd=self.basedir, command=cmd) 
    184184        log = svnlog.execute('.', stdout=PIPE, TZ='UTC') 
    185185 
    … …  
    187187            return [] 
    188188 
    189         return changesets_from_svnlog(log, repository, module) 
    190  
    191     def _applyChangeset(self, root, changeset, logger=None): 
     189        return changesets_from_svnlog(log, 
     190                                      self.repository.repository, 
     191                                      self.repository.module) 
     192 
     193    def _applyChangeset(self, changeset): 
    192194        cmd = [self.repository.SVN_CMD, "update", 
    193195               "--revision", changeset.revision, "."] 
    194         svnup = ExternalCommand(cwd=root, command=cmd) 
     196        svnup = ExternalCommand(cwd=self.basedir, command=cmd) 
    195197        out = svnup.execute(stdout=PIPE) 
    196198 
    … …  
    199201                "%s returned status %s" % (str(svnup), svnup.exit_status)) 
    200202 
    201         if logger: logger.info("%s updated to %s" % ( 
     203        self.log_info("%s updated to %s" % ( 
    202204            ','.join([e.name for e in changeset.entries]), 
    203205            changeset.revision)) 
    … …  
    206208        for line in out: 
    207209            if len(line)>2 and line[0] == 'C' and line[1] == ' ': 
    208                 logger.warn("Conflict after 'svn update': '%s'" % line) 
     210                self.log_info("Conflict after 'svn update': '%s'" % line) 
    209211                result.append(line[2:-1]) 
    210212 
    211213        return result 
    212214 
    213     def _checkoutUpstreamRevision(self, basedir, repository, module, revision, 
    214                                   subdir=None, logger=None, **kwargs): 
     215    def _checkoutUpstreamRevision(self, revision): 
    215216        """ 
    216217        Concretely do the checkout of the upstream revision. 
    … …  
    224225                   "--limit", "1", "--revision", "1:HEAD"] 
    225226            svnlog = ExternalCommand(command=cmd) 
    226             output = svnlog.execute("%s%s" % (repository, module), stdout=PIPE) 
     227            output = svnlog.execute("%s%s" % (self.repository.repository, 
     228                                              self.repository.module), 
     229                                    stdout=PIPE) 
    227230 
    228231            if svnlog.exit_status: 
    … …  
    231234                    (str(output), changes.exit_status, output.read())) 
    232235 
    233             csets = changesets_from_svnlog(output, repository, module) 
     236            csets = changesets_from_svnlog(output, 
     237                                           self.repository.repository, 
     238                                           self.repository.module) 
    234239            revision = escape(csets[0].revision) 
    235240        else: 
    236241            initial = False 
    237242 
    238         wdir = join(basedir, subdir) 
    239         if not exists(join(wdir, '.svn')): 
    240             if logger: logger.info("checking out a working copy") 
     243        if not exists(join(self.basedir, '.svn')): 
     244            self.log_info("checking out a working copy") 
    241245            cmd = [self.repository.SVN_CMD, "co", "--quiet", 
    242246                   "--revision", revision] 
    243             svnco = ExternalCommand(cwd=basedir, command=cmd) 
    244             svnco.execute("%s%s" % (repository, module), subdir) 
     247            svnco = ExternalCommand(command=cmd) 
     248            svnco.execute("%s%s" % (self.repository.repository, 
     249                                    self.repository.module), self.basedir) 
    245250            if svnco.exit_status: 
    246251                raise TargetInitializationFailure( 
    247252                    "%s returned status %s" % (str(svnco), svnco.exit_status)) 
    248253        else: 
    249             if logger: logger.info("%s already exists, assuming it's a svn working dir" % wdir) 
     254            self.log_info("%s already exists, assuming it's a svn working dir" % self.basedir) 
    250255 
    251256        if not initial: 
    252257            cmd = [self.repository.SVN_CMD, "log", "--verbose", "--xml", 
    253258                   "--revision", revision] 
    254             svnlog = ExternalCommand(cwd=wdir, command=cmd) 
     259            svnlog = ExternalCommand(cwd=self.basedir, command=cmd) 
    255260            output = svnlog.execute(stdout=PIPE) 
    256261 
    … …  
    260265                    (str(changes), changes.exit_status, output.read())) 
    261266 
    262             csets = changesets_from_svnlog(output, repository, module) 
     267            csets = changesets_from_svnlog(output, 
     268                                           self.repository.repository, 
     269                                           self.repository.module) 
    263270 
    264271        last = csets[0] 
    265272 
    266         if logger: logger.info("working copy up to svn revision %s", 
    267                                last.revision) 
     273        self.log_info("working copy up to svn revision %s", last.revision) 
    268274 
    269275        return last 
    … …  
    271277    ## SyncronizableTargetWorkingDir 
    272278 
    273     def _addPathnames(self, root, names): 
     279    def _addPathnames(self, names): 
    274280        """ 
    275281        Add some new filesystem objects. 
    … …  
    278284        cmd = [self.repository.SVN_CMD, "add", "--quiet", "--no-auto-props", 
    279285               "--non-recursive"] 
    280         ExternalCommand(cwd=root, command=cmd).execute(names) 
     286        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    281287 
    282288    def _getCommitEntries(self, changeset): 
    … …  
    293299        return entries 
    294300 
    295     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     301    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    296302        """ 
    297303        Commit the changeset. 
    … …  
    326332        cmd = [self.repository.SVN_CMD, "commit", "--quiet", 
    327333               "--file", rontf.name] 
    328         commit = ExternalCommand(cwd=root, command=cmd) 
     334        commit = ExternalCommand(cwd=self.basedir, command=cmd) 
    329335 
    330336        if not entries: 
    … …  
    336342            cmd = [self.repository.SVN_CMD, "propset", "%(propname)s", 
    337343                   "--quiet", "--revprop", "-rHEAD"] 
    338             propset = ExternalCommand(cwd=root, command=cmd) 
     344            propset = ExternalCommand(cwd=self.basedir, command=cmd) 
    339345 
    340346            propset.execute(date.isoformat()+".000000Z", propname='svn:date') 
    341347            propset.execute(author, propname='svn:author') 
    342348 
    343     def _removePathnames(self, root, names): 
     349    def _removePathnames(self, names): 
    344350        """ 
    345351        Remove some filesystem objects. 
    … …  
    347353 
    348354        cmd = [self.repository.SVN_CMD, "remove", "--quiet", "--force"] 
    349         remove = ExternalCommand(cwd=root, command=cmd) 
     355        remove = ExternalCommand(cwd=self.basedir, command=cmd) 
    350356        remove.execute(names) 
    351357 
    352     def _renamePathname(self, root, oldname, newname): 
     358    def _renamePathname(self, oldname, newname): 
    353359        """ 
    354360        Rename a filesystem object. 
    … …  
    356362 
    357363        cmd = [self.repository.SVN_CMD, "mv", "--quiet"] 
    358         move = ExternalCommand(cwd=root, command=cmd) 
     364        move = ExternalCommand(cwd=self.basedir, command=cmd) 
    359365        move.execute(oldname, newname) 
    360366        if move.exit_status: 
    … …  
    365371            # moved the item. OTOH, svn really treats "mv" as "cp+rm", 
    366372            # so we do the same here 
    367             self._removePathnames(root, [oldname]) 
    368             self._addPathnames(root, [newname]) 
     373            self._removePathnames([oldname]) 
     374            self._addPathnames([newname]) 
    369375 
    370376    def __createRepository(self, target_repository, target_module): 
    … …  
    395401                                                  target_module) 
    396402 
    397     def _prepareTargetRepository(self, root, target_repository, target_module): 
     403    def _prepareTargetRepository(self): 
    398404        """ 
    399405        Check for target repository existence, eventually create it. 
    … …  
    402408        cmd = [self.repository.SVN_CMD, "info"] 
    403409        svninfo = ExternalCommand(command=cmd) 
    404         svninfo.execute(target_repository, stdout=PIPE, stderr=STDOUT) 
     410        svninfo.execute(self.repository.repository, stdout=PIPE, stderr=STDOUT) 
    405411 
    406412        if svninfo.exit_status: 
    407             if target_repository.startswith('file:///'): 
    408                 self.__createRepository(target_repository, target_module) 
     413            if self.repository.repository.startswith('file:///'): 
     414                self.__createRepository(self.repository.repository, 
     415                                        self.repository.module) 
    409416            else: 
    410417                raise TargetInitializationFailure("%r does not exist and " 
    … …  
    412419                                                  "it's not a local (file:///) " 
    413420                                                  "repository" % 
    414                                                   target_repository) 
    415  
    416     def _prepareWorkingDirectory(self, root, target_repository, target_module): 
     421                                                  self.repository.repository) 
     422 
     423    def _prepareWorkingDirectory(self): 
    417424        """ 
    418425        Checkout a working copy of the target SVN repository. 
    … …  
    421428        cmd = [self.repository.SVN_CMD, "co", "--quiet"] 
    422429        svnco = ExternalCommand(command=cmd) 
    423         svnco.execute(target_repository + target_module, root) 
    424  
    425     def _initializeWorkingDir(self, root, source_repository, source_module, 
    426                               subdir): 
     430        svnco.execute("%s%s" % (self.repository.repository, 
     431                                self.repository.module), self.basedir) 
     432 
     433    def _initializeWorkingDir(self): 
    427434        """ 
    428435        Add the given directory to an already existing svn working tree. 
    … …  
    431438        from os.path import exists, join 
    432439 
    433         if not exists(join(root, '.svn')): 
    434             raise TargetInitializationFailure("'%s' needs to be an SVN working copy already under SVN" % root) 
    435  
    436         SyncronizableTargetWorkingDir._initializeWorkingDir(self, root, 
    437                                                             source_repository, 
    438                                                             source_module, 
    439                                                             subdir) 
     440        if not exists(join(self.basedir, '.svn')): 
     441            raise TargetInitializationFailure("'%s' needs to be an SVN working copy already under SVN" % self.basedir) 
     442 
     443        SyncronizableTargetWorkingDir._initializeWorkingDir(self) 

  • vcpx/dualwd.py

    r511 r527  
    5252        self.replayChangeset = self.target.replayChangeset 
    5353 
    54     def applyPendingChangesets(self, root, module, applyable=None, 
    55                                 replay=None, applied=None, logger=None): 
    56         return self.source.applyPendingChangesets(root, module, 
    57                                                   replay=self.replayChangeset, 
     54    def applyPendingChangesets(self, applyable=None, replay=None, applied=None): 
     55        return self.source.applyPendingChangesets(replay=self.replayChangeset, 
    5856                                                  applyable=applyable, 
    59                                                   applied=applied, 
    60                                                   logger=logger) 
     57                                                  applied=applied) 

  • vcpx/tailor.py

    r525 r527  
    4545        """ 
    4646 
    47         self.project.log_info("Bootstrapping '%s'" % self.project.root) 
     47        self.project.log_info("Bootstrapping '%s'" % self.project.rootdir) 
    4848 
    4949        try: 

  • vcpx/cvs.py

    r515 r527  
    287287    """ 
    288288 
    289     def _getUpstreamChangesets(self, root, repository, module, sincerev=None, 
    290                               branch=None): 
     289    def _getUpstreamChangesets(self, sincerev): 
    291290        from os.path import join, exists 
    292291        from datetime import timedelta 
    293292 
    294         if branch is None: 
    295             entries = CvsEntries(root) 
    296             youngest_entry = entries.getYoungestEntry() 
    297             if youngest_entry is None: 
    298                 raise EmptyRepositoriesFoolsMe("The working copy '%s' of the CVS repository seems empty, don't know how to deal with that." % root) 
    299  
    300             branch = '' 
    301             fname = join(root, 'CVS', 'Tag') 
    302             if exists(fname): 
    303                 tag = open(fname).read() 
    304                 if tag[0] in 'NT': 
    305                     branch=tag[1:-1] 
     293        entries = CvsEntries(self.basedir) 
     294        youngest_entry = entries.getYoungestEntry() 
     295        if youngest_entry is None: 
     296            raise EmptyRepositoriesFoolsMe("The working copy '%s' of the CVS repository seems empty, don't know how to deal with that." % self.basedir) 
     297 
     298        branch = '' 
     299        fname = join(self.basedir, 'CVS', 'Tag') 
     300        if exists(fname): 
     301            tag = open(fname).read() 
     302            if tag[0] in 'NT': 
     303                branch=tag[1:-1] 
    306304 
    307305        if not sincerev: 

  • vcpx/monotone.py

    r515 r527  
    2222    ## SyncronizableTargetWorkingDir 
    2323 
    24     def _addPathnames(self, root, names): 
     24    def _addPathnames(self, names): 
    2525        """ 
    2626        Add some new filesystem objects. 
    … …  
    2828 
    2929        cmd = [self.repository.MONOTONE_CMD, "add"] 
    30         add = ExternalCommand(cwd=root, command=cmd) 
     30        add = ExternalCommand(cwd=self.basedir, command=cmd) 
    3131        add.execute(names) 
    3232 
    33     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     33    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    3434        """ 
    3535        Commit the changeset. 
    … …  
    5656               "--date", date.isoformat(), 
    5757               "--message-file", rontf.name] 
    58         commit = ExternalCommit(cwd=root, command=cmd) 
     58        commit = ExternalCommit(cwd=self.basedir, command=cmd) 
    5959 
    6060        if not entries: 
    … …  
    7474                stderr.write("No changes to commit - changeset ignored\n") 
    7575 
    76     def _removePathnames(self, root, names): 
     76    def _removePathnames(self, names): 
    7777        """ 
    7878        Remove some filesystem object. 
    … …  
    8080 
    8181        cmd = [self.repository.MONOTONE_CMD, "drop"] 
    82         drop = ExternalCommand(cwd=root, command=cmd) 
     82        drop = ExternalCommand(cwd=self.basedir, command=cmd) 
    8383        drop.execute(names) 
    8484 
    85     def _renamePathname(self, root, oldname, newname): 
     85    def _renamePathname(self, oldname, newname): 
    8686        """ 
    8787        Rename a filesystem object. 
    … …  
    8989 
    9090        cmd = [self.repository.MONOTONE_CMD, "rename"] 
    91         rename = ExternalCommand(cwd=root, command=cmd) 
     91        rename = ExternalCommand(cwd=self.basedir, command=cmd) 
    9292        rename.execute(oldname, newname) 
    9393 
    94     def _initializeWorkingDir(self, root, source_repository, source_module, 
    95                               subdir): 
     94    def _initializeWorkingDir(self): 
    9695        """ 
    9796        Setup the monotone working copy 
    … …  
    105104        from os.path import exists, join 
    106105 
    107         if not exists(join(root, 'MT')): 
    108             raise TargetInitializationFailure("Please setup '%s' as a monotone working directory" % root) 
     106        if not exists(join(self.basedir, 'MT')): 
     107            raise TargetInitializationFailure("Please setup '%s' as a monotone working directory" % self.basedir) 
    109108 
    110         self._addPathnames(root, [subdir]) 
     109        self._addPathnames([self.repository.subdir]) 

  • vcpx/cdv.py

    r515 r527  
    1919    ## SyncronizableTargetWorkingDir 
    2020 
    21     def _addPathnames(self, root, names): 
     21    def _addPathnames(self, names): 
    2222        """ 
    2323        Add some new filesystem objects. 
    … …  
    2525 
    2626        cmd = [self.repository.CDV_CMD, "add"] 
    27         ExternalCommand(cwd=root, command=cmd).execute(names) 
     27        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    2828 
    29     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     29    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    3030        """ 
    3131        Commit the changeset. 
    … …  
    5050            entries = ['.'] 
    5151 
    52         ExternalCommand(cwd=root, command=cmd).execute(entries) 
     52        ExternalCommand(cwd=self.basedir, command=cmd).execute(entries) 
    5353 
    54     def _removePathnames(self, root, names): 
     54    def _removePathnames(self, names): 
    5555        """ 
    5656        Remove some filesystem object. 
    … …  
    5858 
    5959        cmd = [self.repository.CDV_CMD, "remove"] 
    60         ExternalCommand(cwd=root, command=cmd).execute(names) 
     60        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    6161 
    62     def _renamePathname(self, root, oldname, newname): 
     62    def _renamePathname(self, oldname, newname): 
    6363        """ 
    6464        Rename a filesystem object. 
    … …  
    6666 
    6767        cmd = [self.repository.CDV_CMD, "rename"] 
    68         ExternalCommand(cwd=root, command=cmd).execute(oldname, newname) 
     68        ExternalCommand(cwd=self.basedir, command=cmd).execute(oldname, newname) 
    6969 
    70     def initializeNewWorkingDir(self, root, source_repository, source_module, 
    71                                 subdir, changeset, initial): 
     70    def initializeNewWorkingDir(self, source_repo, changeset, initial): 
    7271        """ 
    7372        Initialize a new working directory, just extracted from 
    … …  
    7877             BOOTSTRAP_CHANGELOG 
    7978 
    80         self._initializeWorkingDir(root, source_repository, source_module, 
    81                                    subdir) 
     79        self._initializeWorkingDir() 
    8280        revision = changeset.revision 
     81        source_repository = source_repo.repository 
     82        source_module = source_repo.module 
    8383        if initial: 
    8484            author = changeset.author 
    … …  
    8989            patchname = BOOTSTRAP_PATCHNAME % source_module 
    9090            log = BOOTSTRAP_CHANGELOG % locals() 
    91         self._commit(root, changeset.date, author, patchname, log, 
    92                      entries=[subdir, '%s/...' % subdir]) 
     91        self._commit(changeset.date, author, patchname, log, 
     92                     entries=['%s/...' % self.basedir]) 
    9393 
    94     def _initializeWorkingDir(self, root, source_repository, source_module, 
    95                               subdir): 
     94    def _initializeWorkingDir(self): 
    9695        """ 
    9796        Execute ``cdv init``. 
    … …  
    101100        from os.path import join 
    102101 
    103         init = ExternalCommand(cwd=root, command=[self.repository.CDV_CMD, "init"]) 
     102        init = ExternalCommand(cwd=self.basedir, 
     103                               command=[self.repository.CDV_CMD, "init"]) 
    104104        init.execute() 
    105105 
    … …  
    110110        cmd = [self.repository.CDV_CMD, "set", "user"] 
    111111        user = getenv('CDV_USER') or getenv('LOGNAME') 
    112         ExternalCommand(cwd=root, command=cmd).execute(user) 
     112        ExternalCommand(cwd=self.basedir, command=cmd).execute(user) 
    113113 
    114         SyncronizableTargetWorkingDir._initializeWorkingDir(self, root, 
    115                                                             source_repository, 
    116                                                             source_module, 
    117                                                             subdir) 
     114        SyncronizableTargetWorkingDir._initializeWorkingDir(self) 

  • vcpx/bzr.py

    r515 r527  
    1919    ## SyncronizableTargetWorkingDir 
    2020 
    21     def _addEntries(self, root, entries): 
     21    def _addEntries(self, entries): 
    2222        """ 
    2323        Add a sequence of entries. 
    … …  
    2525 
    2626        cmd = [self.repository.BZR_CMD, "add"] 
    27         ExternalCommand(cwd=root, command=cmd).execute(entries) 
     27        ExternalCommand(cwd=self.basedir, command=cmd).execute(entries) 
    2828 
    29     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     29    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    3030        """ 
    3131        Commit the changeset. 
    … …  
    5050            entries = ['.'] 
    5151 
    52         ExternalCommand(cwd=root, command=cmd).execute(entries) 
     52        ExternalCommand(cwd=self.basedir, command=cmd).execute(entries) 
    5353 
    54     def _removeEntries(self, root, entries): 
     54    def _removeEntries(self, entries): 
    5555        """ 
    5656        Remove a sequence of entries. 
    … …  
    5858 
    5959        cmd = [self.repository.BZR_CMD, "remove"] 
    60         ExternalCommand(cwd=root, command=cmd).execute(entries) 
     60        ExternalCommand(cwd=self.basedir, command=cmd).execute(entries) 
    6161 
    62     def _renameEntry(self, root, oldentry, newentry): 
     62    def _renameEntry(self, oldentry, newentry): 
    6363        """ 
    6464        Rename an entry. 
    … …  
    6666 
    6767        cmd = [self.repository.BZR_CMD, "rename"] 
    68         ExternalCommand(cwd=root, command=cmd).execute(old, new) 
     68        ExternalCommand(cwd=self.basedir, command=cmd).execute(old, new) 
    6969 
    70     def initializeNewWorkingDir(self, root, source_repository, 
    71                                 source_module, subdir, changeset, initial): 
     70    def initializeNewWorkingDir(self, source_repo, changeset, initial): 
    7271        """ 
    7372        Initialize a new working directory, just extracted from 
    … …  
    7877             BOOTSTRAP_CHANGELOG 
    7978 
    80         self._initializeWorkingDir(root, source_repository, source_module, 
    81                                    subdir) 
     79        self._initializeWorkingDir() 
    8280        revision = changeset.revision 
     81        source_repository = source_repo.repository 
     82        source_module = source_repo.module 
    8383        if initial: 
    8484            author = changeset.author 
    … …  
    8989            patchname = BOOTSTRAP_PATCHNAME % source_module 
    9090            log = BOOTSTRAP_CHANGELOG % locals() 
    91         self._commit(root, changeset.date, author, patchname, log, 
    92                      entries=[subdir, '%s/...' % subdir]) 
     91        self._commit(changeset.date, author, patchname, log, 
     92                     entries=['%s/...' % self.basedir]) 
    9393 
    94     def _initializeWorkingDir(self, root, source_repository, source_module, 
    95                               subdir): 
     94    def _initializeWorkingDir(self): 
    9695        """ 
    9796        Execute ``bzr init``. 
    … …  
    103102 
    104103        cmd = [self.repository.BZR_CMD, "init"] 
    105         init = ExternalCommand(cwd=root, command=cmd) 
     104        init = ExternalCommand(cwd=self.basedir, command=cmd) 
    106105        init.execute() 
    107106 
    … …  
    112111        # Create the .bzrignore file, that contains a glob per line, 
    113112        # with all known VCs metadirs to be skipped. 
    114         ignore = open(join(root, '.hgignore'), 'w') 
     113        ignore = open(join(self.basedir, '.hgignore'), 'w') 
    115114        ignore.write('\n'.join(['(^|/)%s($|/)' % md 
    116115                                for md in IGNORED_METADIRS])) 
    … …  
    118117        ignore.close() 
    119118 
    120         SyncronizableTargetWorkingDir._initializeWorkingDir(self, root, 
    121                                                             source_repository, 
    122                                                             source_module, 
    123                                                             subdir) 
     119        SyncronizableTargetWorkingDir._initializeWorkingDir(self) 

  • vcpx/session.py

    r511 r527  
    520520            return 
    521521 
    522     def willApply(self, root, changeset): 
     522    def willApply(self, changeset): 
    523523        """ 
    524524        Print the changeset being applied. 
    … …  
    533533        return True 
    534534 
    535     def shouldApply(self, root, changeset): 
     535    def shouldApply(self, changeset): 
    536536        """ 
    537537        Ask weather a changeset should be applied. 
    … …  
    561561                self.stdout.write(str(changeset) + '\n') 
    562562 
    563     def applied(self, root, changeset): 
     563    def applied(self, changeset): 
    564564        """ 
    565565        Save current status. 

  • vcpx/hg.py

    r515 r527  
    1919    ## SyncronizableTargetWorkingDir 
    2020 
    21     def _addPathnames(self, root, names): 
     21    def _addPathnames(self, names): 
    2222        """ 
    2323        Add some new filesystem objects. 
    … …  
    2929        # them out. 
    3030 
    31         notdirs = [n for n in names if not isdir(join(root, n))] 
     31        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    3232        if notdirs: 
    3333            cmd = [self.repository.HG_CMD, "add"] 
    34             ExternalCommand(cwd=root, command=cmd).execute(notdirs) 
     34            ExternalCommand(cwd=self.basedir, command=cmd).execute(notdirs) 
    3535 
    36     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     36    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    3737        """ 
    3838        Commit the changeset. 
    … …  
    5555               "-l", "%(logfile)s", 
    5656               "-d", "%(time)s UTC"] 
    57         c = ExternalCommand(cwd=root, command=cmd) 
     57        c = ExternalCommand(cwd=self.basedir, command=cmd) 
    5858 
    5959        rontf = ReopenableNamedTemporaryFile('hg', 'tailor') 
    … …  
    6464        c.execute(logfile=rontf.name, time=mktime(date.timetuple())) 
    6565 
    66     def _removePathnames(self, root, names): 
     66    def _removePathnames(self, names): 
    6767        """ 
    6868        Remove some filesystem object. 
    … …  
    7474        # them out. 
    7575 
    76         notdirs = [n for n in names if not isdir(join(root, n))] 
     76        notdirs = [n for n in names if not isdir(join(self.basedir, n))] 
    7777        if notdirs: 
    7878            cmd = [self.repository.HG_CMD, "remove"] 
    79             ExternalCommand(cwd=root, command=cmd).execute(notdirs) 
     79            ExternalCommand(cwd=self.basedir, command=cmd).execute(notdirs) 
    8080 
    81     def _renamePathname(self, root, oldname, newname): 
     81    def _renamePathname(self, oldname, newname): 
    8282        """ 
    8383        Rename a filesystem object. 
    … …  
    8989 
    9090        cmd = [self.repository.HG_CMD, "copy"] 
    91         copy = ExternalCommand(cwd=root, command=cmd) 
    92         if isdir(join(root, newname)): 
     91        copy = ExternalCommand(cwd=self.basedir, command=cmd) 
     92        if isdir(join(self.basedir, newname)): 
    9393            # Given lack of support for directories in current HG, 
    9494            # loop over all files under the new directory and 
    9595            # do a copy on them. 
    96             skip = len(root)+len(newname)+2 
    97             for dir, subdirs, files in walk(join(root, newname)): 
     96            skip = len(self.basedir)+len(newname)+2 
     97            for dir, subdirs, files in walk(join(self.basedir, newname)): 
    9898                prefix = dir[skip:] 
    9999 
    … …  
    108108            copy.execute(oldname, newname) 
    109109 
    110     def _initializeWorkingDir(self, root, source_repository, source_module, 
    111                               subdir): 
     110    def _initializeWorkingDir(self): 
    112111        """ 
    113112        Execute ``hg init``. 
    … …  
    119118        from dualwd import IGNORED_METADIRS 
    120119 
    121         init = ExternalCommand(cwd=root, 
     120        init = ExternalCommand(cwd=self.basedir, 
    122121                               command=[self.repository.HG_CMD, "init"]) 
    123122        init.execute() 
    … …  
    129128        # Create the .hgignore file, that contains a regexp per line 
    130129        # with all known VCs metadirs to be skipped. 
    131         ignore = open(join(root, '.hgignore'), 'w') 
     130        ignore = open(join(self.basedir, '.hgignore'), 'w') 
    132131        ignore.write('\n'.join(['(^|/)%s($|/)' % escape(md) 
    133132                                for md in IGNORED_METADIRS])) 
    … …  
    135134        ignore.close() 
    136135 
    137         ExternalCommand(cwd=root, 
     136        ExternalCommand(cwd=self.basedir, 
    138137                        command=[self.repository.HG_CMD, "addremove"]).execute() 

  • vcpx/project.py

    r522 r527  
    6666 
    6767    def __str__(self): 
    68         return "Project %s at %s:\n\t" % (self.name, self.root) + \ 
     68        return "Project %s at %s:\n\t" % (self.name, self.rootdir) + \ 
    6969               "\n\t".join(['%s = %s' % (v, getattr(self, v)) 
    7070                            for v in ('source', 'target', 'state_file')]) 
    … …  
    7979        import logging 
    8080 
    81         self.root = self.config.get(self.name, 'root', getcwd()) 
    82         if not exists(self.root): 
    83             makedirs(self.root) 
     81        self.rootdir = self.config.get(self.name, 'root-directory', getcwd()) 
     82        if not exists(self.rootdir): 
     83            makedirs(self.rootdir) 
    8484        self.subdir = self.config.get(self.name, 'subdir') 
    8585        if not self.subdir: 
    … …  
    112112        self.logger = logging.getLogger('tailor.%s' % self.name) 
    113113        logfile = self.config.get(self.name, 'logfile', 'tailor.log') 
    114         hdlr = logging.FileHandler(join(self.root, logfile)) 
     114        hdlr = logging.FileHandler(join(self.rootdir, logfile)) 
    115115        formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s') 
    116116        hdlr.setFormatter(formatter) 
    … …  
    186186 
    187187        dwd = self.workingDir() 
    188         dwd.prepareWorkingDirectory(self.root, 
    189                                     self.target.repository, 
    190                                     self.target.module) 
     188        dwd.prepareWorkingDirectory() 
    191189 
    192190    def checkoutUpstreamRevision(self): 
    … …  
    198196        dwd = self.workingDir() 
    199197        revision = self.config.get(self.name, 'start-revision', 'INITIAL') 
    200         actual = dwd.checkoutUpstreamRevision(self.root, 
    201                                             self.source.repository, 
    202                                             self.source.module, revision, 
    203                                             subdir=self.subdir, 
    204                                             logger=self.logger) 
    205         dwd.initializeNewWorkingDir(self.root, self.source.repository, 
    206                                     self.source.module, self.subdir, 
    207                                     actual, revision=='INITIAL') 
    208  
    209     def _applyable(self, root, changeset): 
     198        actual = dwd.checkoutUpstreamRevision(revision) 
     199        dwd.initializeNewWorkingDir(self.source, actual, revision=='INITIAL') 
     200 
     201    def _applyable(self, changeset): 
    210202        """ 
    211203        Print the changeset being applied. 
    … …  
    221213        return True 
    222214 
    223     def _applied(self, root, changeset): 
     215    def _applied(self, changeset): 
    224216        """ 
    225217        Save current status. 
    … …  
    234226        """ 
    235227 
    236         from os.path import join 
    237  
    238         wdir = join(self.root, self.subdir) 
    239228        dwd = self.workingDir() 
    240229        try: 
    241             pendings = dwd.getPendingChangesets(wdir, 
    242                                                 self.source.repository, 
    243                                                 self.source.module) 
     230            pendings = dwd.getPendingChangesets() 
    244231        except KeyboardInterrupt: 
    245232            self.log_info("Leaving '%s' unchanged, stopped by user" % self.name) 
    … …  
    256243            try: 
    257244                last, conflicts = dwd.applyPendingChangesets( 
    258                     wdir, self.source.module, 
    259                     applyable=self._applyable, applied=self._applied, 
    260                     logger=self.logger) 
     245                    applyable=self._applyable, applied=self._applied) 
    261246            except: 
    262247                self.log_error('Upstream change application failed', True) 
    … …  
    265250            if last: 
    266251                self.log_info("Update completed, now at revision '%s'" % 
    267                               self.upstream_revision) 
     252                              last.revision) 
    268253        else: 
    269254            self.log_info("Update completed with no upstream changes") 

  • vcpx/repository.py

    r521 r527  
    3535        as ``source-repository`` (or ``target-repository``) in its [DEFAULT] 
    3636        section. 
     37 
     38        If the configuration does not specify a specific ``root-directory`` 
     39        take the one from the project. 
    3740        """ 
    3841 
    … …  
    4548        self.module = config.get(self.name, 'module') or \ 
    4649                      config.get(self.name, '%s-module' % which) 
    47         if not self.module and self.repository: 
    48             self.module = split(self.repository)[1] 
     50        self.rootdir = config.get(self.name, 'root-directory', 
     51                                  self.project.rootdir) 
     52        self.subdir = config.get(self.name, 'subdir', self.project.subdir) 
     53 
     54    def _validateConfiguration(self): 
     55        """ 
     56        Validate the configuration, possibly altering/completing it. 
     57        """ 
     58 
     59    def log_info(self, what): 
     60        """ 
     61        Print some info on the log and, in verbose mode, to stdout as well. 
     62        """ 
     63 
     64        self.project.log_info(what) 
     65 
     66    def log_error(self, what, exc=False): 
     67        """ 
     68        Print an error message, possibly with an exception traceback, 
     69        to the log and to stdout as well. 
     70        """ 
     71 
     72        self.project.log_error(what, exc) 
    4973 
    5074    def workingDir(self): 
    … …  
    5377        repository. 
    5478        """ 
     79 
     80        from source import InvocationError 
     81 
     82        self._validateConfiguration() 
    5583 
    5684        wdname = self.kind.capitalize() + 'WorkingDir' 
    … …  
    6189        except (AttributeError, ImportError): 
    6290            raise InvocationError("Unhandled source VCS kind: " + self.kind) 
    63         return workingdir() 
     91 
     92        return workingdir(self) 
    6493 
    6594 
    … …  
    73102 
    74103 
     104 
    75105class BzrRepository(Repository): 
    76106    METADIR = '.bzr' 
    … …  
    99129        self.CVS_CMD = config.get(self.name, 'cvs-command', self.CVS_CMD) 
    100130 
     131    def _validateConfiguration(self): 
     132        from os.path import split 
     133        from config import ConfigurationError 
     134 
     135 
     136        if not self.module and self.repository: 
     137            self.module = split(self.repository)[1] 
     138 
     139        if not self.module: 
     140            raise ConfigurationError("Must specify a repository and maybe a module also") 
    101141 
    102142class CvspsRepository(CvsRepository): 
    … …  
    148188                                       'svnadmin-command', self.SVNADMIN_CMD) 
    149189        self.use_propset = config.get(self.name, 'use-propset', False) 
     190 
     191    def _validateConfiguration(self): 
     192        if not self.module: 
     193            raise ConfigurationError("Must the path within the " 
     194                                     "Subversion repository") 
     195 
    150196        if not self.module.startswith('/'): 
     197            self.project.log_info("Prepending '/' to module") 
    151198            self.module = '/' + self.module 
    152199 

  • vcpx/arx.py

    r515 r527  
    2020    ## SyncronizableTargetWorkingDir 
    2121 
    22     def _addPathnames(self, root, names): 
     22    def _addPathnames(self, names): 
    2323        """ 
    2424        Add some new filesystem objects. 
    2525        """ 
    2626 
    27         from os.path import join, isdir 
     27        cmd = [self.repository.ARX_CMD, "add"] 
     28        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    2829 
    29         cmd = [self.repository.ARX_CMD, "add"] 
    30         ExternalCommand(cwd=root, command=cmd).execute(names) 
    31  
    32     def _commit(self,root, date, author, patchname, changelog=None, entries=None): 
     30    def _commit(self, date, author, patchname, changelog=None, entries=None): 
    3331        """ 
    3432        Commit the changeset. 
    … …  
    5250            logmessage=" " 
    5351 
    54         cmd = [self.repository.ARX_CMD, "commit", "-s", logmessage, "--author", author, 
     52        cmd = [self.repository.ARX_CMD, "commit", "-s", logmessage, 
     53               "--author", author, 
    5554               "--date", date.isoformat()] 
    56         c = ExternalCommand(cwd=root, command=cmd) 
     55        c = ExternalCommand(cwd=self.basedir, command=cmd) 
    5756        c.execute() 
    5857 
    59     def _removePathnames(self, root, names): 
     58    def _removePathnames(self, names): 
    6059        """ 
    6160        Remove some filesystem object. 
    6261        """ 
     62 
    6363        cmd = [self.repository.ARX_CMD, "rm"] 
    64         ExternalCommand(cwd=root, command=cmd).execute(names) 
     64        ExternalCommand(cwd=self.basedir, command=cmd).execute(names) 
    6565 
    66     def _renamePathname(self, root, oldname, newname): 
     66    def _renamePathname(self, oldname, newname): 
    6767        """ 
    6868        Rename a filesystem object. 
    … …  
    7070 
    7171        cmd = [self.repository.ARX_CMD, "copy"] 
    72         rename = ExternalCommand(cwd=root, command=cmd) 
    73         rename.execute(oldname,newname) 
     72        rename = ExternalCommand(cwd=self.basedir, command=cmd) 
     73        rename.execute(oldname, newname) 
    7474 
    75     def _initializeWorkingDir(self, root, repository, module, subdir): 
     75    def _initializeWorkingDir(self): 
    7676        """ 
    7777        Setup the ArX working copy 
    … …  
    8888        from os import walk 
    8989 
    90         if not exists(join(root, '_arx')): 
    91             raise TargetInitializationFailure("Please setup '%s' as an ArX working directory" % root) 
     90        if not exists(join(self.basedir, '_arx')): 
     91            raise TargetInitializationFailure("Please setup '%s' as an ArX working directory" % self.basedir) 
    9292 
    93         self._addPathnames(root, [subdir]) 
    94  
    95         cmd = [self.repository.ARX_CMD, "add"] 
    96         add_path = ExternalCommand(cwd=root, command=cmd) 
    97  
    98         for root, dirs, files in walk(root): 
    99             for f in files: 
    100                 if f!="tailor.log" and f!="tailor.info": 
    101                     add_path.execute(join(root,f)) 
    102             for metadir in IGNORED_METADIRS: 
    103                 if metadir in dirs: 
    104                     dirs.remove(metadir) 
    105             for d in dirs: 
    106                 add_path.execute(join(root,d)) 
     93        SyncronizableTargetWorkingDir._initializeWorkingDir(self) 
Note: See TracChangeset for help on using the changeset viewer.