usr/src/tools/onbld/Scm/WorkSpace.py

   1 #
   2 #  This program is free software; you can redistribute it and/or modify
   3 #  it under the terms of the GNU General Public License version 2
   4 #  as published by the Free Software Foundation.
   5 #
   6 #  This program is distributed in the hope that it will be useful,
   7 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 #  GNU General Public License for more details.
  10 #
  11 #  You should have received a copy of the GNU General Public License
  12 #  along with this program; if not, write to the Free Software
  13 #  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  14 #
  15
  16 #
  17 # Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  18 # Copyright 2008, 2011, Richard Lowe
  19 #
  20
  21 #
  22 # Theory:
  23 #
  24 # Workspaces have a non-binding parent/child relationship.
  25 # All important operations apply to the changes between the two.
  26 #
  27 # However, for the sake of remote operation, the 'parent' of a
  28 # workspace is not seen as a literal entity, instead the figurative
  29 # parent contains the last changeset common to both parent and child,
  30 # as such the 'parent tip' is actually nothing of the sort, but instead a
  31 # convenient imitation.
  32 #
  33 # Any change made to a workspace is a change to a file therein, such
  34 # changes can be represented briefly as whether the file was
  35 # modified/added/removed as compared to the parent workspace, whether
  36 # the file has a different name in the parent and if so, whether it
  37 # was renamed or merely copied.  Each changed file has an
  38 # associated ActiveEntry.
  39 #
  40 # The ActiveList, being a list of ActiveEntry objects, can thus
  41 # present the entire change in workspace state between a parent and
  42 # its child and is the important bit here (in that if it is incorrect,
  43 # everything else will be as incorrect, or more)
  44 #
  45
  46 import cStringIO
  47 import os
  48 from mercurial import cmdutil, context, error, hg, node, patch, repair, util
  49 from hgext import mq
  50
  51 from onbld.Scm import Version
  52
  53
  54 #
  55 # Mercurial 1.6 moves findoutgoing into a discover module
  56 #
  57 if Version.at_least("1.6"):
  58     from mercurial import discovery
  59
  60
  61 class ActiveEntry(object):
  62     '''Representation of the changes made to a single file.
  63
  64     MODIFIED   - Contents changed, but no other changes were made
  65     ADDED      - File is newly created
  66     REMOVED    - File is being removed
  67
  68     Copies are represented by an Entry whose .parentname is non-nil
  69
  70     Truly copied files have non-nil .parentname and .renamed = False
  71     Renames have non-nil .parentname and .renamed = True
  72
  73     Do not access any of this information directly, do so via the
  74
  75     .is_<change>() methods.'''
  76
  77     MODIFIED = intern('modified')
  78     ADDED = intern('added')
  79     REMOVED = intern('removed')
  80
  81     def __init__(self, name, change):
  82         self.name = name
  83         self.change = intern(change)
  84
  85         assert change in (self.MODIFIED, self.ADDED, self.REMOVED)
  86
  87         self.parentname = None
  88         # As opposed to copied (or neither)
  89         self.renamed = False
  90         self.comments = []
  91
  92     def __cmp__(self, other):
  93         return cmp(self.name, other.name)
  94
  95     def is_added(self):
  96         '''Return True if this ActiveEntry represents an added file'''
  97         return self.change is self.ADDED
  98
  99     def is_modified(self):
 100         '''Return True if this ActiveEntry represents a modified file'''
 101         return self.change is self.MODIFIED
 102
 103     def is_removed(self):
 104         '''Return True if this ActiveEntry represents a removed file'''
 105         return self.change is self.REMOVED
 106
 107     def is_renamed(self):
 108         '''Return True if this ActiveEntry represents a renamed file'''
 109         return self.parentname and self.renamed
 110
 111     def is_copied(self):
 112         '''Return True if this ActiveEntry represents a copied file'''
 113         return self.parentname and not self.renamed
 114
 115
 116 class ActiveList(object):
 117     '''Complete representation of change between two changesets.
 118
 119     In practice, a container for ActiveEntry objects, and methods to
 120     create them, and deal with them as a group.'''
 121
 122     def __init__(self, ws, parenttip, revs=None):
 123         '''Initialize the ActiveList
 124
 125         parenttip is the revision with which to compare (likely to be
 126         from the parent), revs is a topologically sorted list of
 127         revisions ending with the revision to compare with (likely to
 128         be the child-local revisions).'''
 129
 130         assert parenttip is not None
 131
 132         self.ws = ws
 133         self.revs = revs
 134         self.parenttip = parenttip
 135         self.localtip = None
 136
 137         self._active = {}
 138         self._comments = []
 139
 140         if revs:
 141             self.localtip = revs[-1]
 142             self._build()
 143
 144     def _status(self):
 145         '''Return the status of any file mentioned in any of the
 146         changesets making up this active list.'''
 147
 148         files = set()
 149         for c in self.revs:
 150             files.update(c.files())
 151
 152         #
 153         # Any file not in the parenttip or the localtip is ephemeral
 154         # and can be ignored. Mercurial will complain regarding these
 155         # files if the localtip is a workingctx, so remove them in
 156         # that case.
 157         #
 158         # Compare against the dirstate because a workingctx manifest
 159         # is created on-demand and is particularly expensive.
 160         #
 161         if self.localtip.rev() is None:
 162             for f in files.copy():
 163                 if f not in self.parenttip and f not in self.ws.repo.dirstate:
 164                     files.remove(f)
 165
 166         return self.ws.status(self.parenttip, self.localtip, files=files)
 167
 168     def _build(self):
 169         '''Construct ActiveEntry objects for each changed file.
 170
 171         This works in 3 stages:
 172
 173           - Create entries for every changed file with
 174             semi-appropriate change type
 175
 176           - Track renames/copies, and set change comments (both
 177             ActiveList-wide, and per-file).
 178
 179           - Cleanup
 180             - Drop circular renames
 181             - Drop the removal of the old name of any rename
 182             - Drop entries for modified files that haven't actually changed'''
 183
 184         #
 185         # Keep a cache of filectx objects (keyed on pathname) so that
 186         # we can avoid opening filelogs numerous times.
 187         #
 188         fctxcache = {}
 189
 190         def oldname(ctx, fname):
 191             '''Return the name 'fname' held prior to any possible
 192             rename/copy in the given changeset.'''
 193             try:
 194                 if fname in fctxcache:
 195                     octx = fctxcache[fname]
 196                     fctx = ctx.filectx(fname, filelog=octx.filelog())
 197                 else:
 198                     fctx = ctx.filectx(fname)
 199                     #
 200                     # workingfilectx objects may not refer to the
 201                     # right filelog (in case of rename).  Don't cache
 202                     # them.
 203                     #
 204                     if not isinstance(fctx, context.workingfilectx):
 205                         fctxcache[fname] = fctx
 206             except error.LookupError:
 207                 return None
 208
 209             rn = fctx.renamed()
 210             return rn and rn[0] or fname
 211
 212         status = self._status()
 213         self._active = dict((fname, ActiveEntry(fname, kind))
 214                             for fname, kind in status.iteritems()
 215                             if kind in ('modified', 'added', 'removed'))
 216
 217         #
 218         # We do two things:
 219         #    - Gather checkin comments (for the entire ActiveList, and
 220         #      per-file)
 221         #    - Set the .parentname of any copied/renamed file
 222         #
 223         # renames/copies:
 224         #   We walk the list of revisions backward such that only files
 225         #   that ultimately remain active need be considered.
 226         #
 227         #   At each iteration (revision) we update the .parentname of
 228         #   any active file renamed or copied in that revision (the
 229         #   current .parentname if set, or .name otherwise, reflects
 230         #   the name of a given active file in the revision currently
 231         #   being looked at)
 232         #
 233         for ctx in reversed(self.revs):
 234             desc = ctx.description().splitlines()
 235             self._comments = desc + self._comments
 236             cfiles = set(ctx.files())
 237
 238             for entry in self:
 239                 fname = entry.parentname or entry.name
 240                 if fname not in cfiles:
 241                     continue
 242
 243                 entry.comments = desc + entry.comments
 244
 245                 #
 246                 # We don't care about the name history of any file
 247                 # that ends up being removed, since that trumps any
 248                 # possible renames or copies along the way.
 249                 #
 250                 # Changes that we may care about involving an
 251                 # intermediate name of a removed file will appear
 252                 # separately (related to the eventual name along
 253                 # that line)
 254                 #
 255                 if not entry.is_removed():
 256                     entry.parentname = oldname(ctx, fname)
 257
 258         for entry in self._active.values():
 259             #
 260             # For any file marked as copied or renamed, clear the
 261             # .parentname if the copy or rename is cyclic (source ==
 262             # destination) or if the .parentname did not exist in the
 263             # parenttip.
 264             #
 265             # If the parentname is marked as removed, set the renamed
 266             # flag and remove any ActiveEntry we may have for the
 267             # .parentname.
 268             #
 269             if entry.parentname:
 270                 if (entry.parentname == entry.name or
 271                     entry.parentname not in self.parenttip):
 272                     entry.parentname = None
 273                 elif status.get(entry.parentname) == 'removed':
 274                     entry.renamed = True
 275
 276                     if entry.parentname in self:
 277                         del self[entry.parentname]
 278
 279             #
 280             # There are cases during a merge where a file will be seen
 281             # as modified by status but in reality be an addition (not
 282             # in the parenttip), so we have to check whether the file
 283             # is in the parenttip and set it as an addition, if not.
 284             #
 285             # If a file is modified (and not a copy or rename), we do
 286             # a full comparison to the copy in the parenttip and
 287             # ignore files that are parts of active revisions but
 288             # unchanged.
 289             #
 290             if entry.name not in self.parenttip:
 291                 entry.change = ActiveEntry.ADDED
 292             elif entry.is_modified():
 293                 if not self._changed_file(entry.name):
 294                     del self[entry.name]
 295
 296     def __contains__(self, fname):
 297         return fname in self._active
 298
 299     def __getitem__(self, key):
 300         return self._active[key]
 301
 302     def __setitem__(self, key, value):
 303         self._active[key] = value
 304
 305     def __delitem__(self, key):
 306         del self._active[key]
 307
 308     def __iter__(self):
 309         return self._active.itervalues()
 310
 311     def files(self):
 312         '''Return the list of pathnames of all files touched by this
 313         ActiveList
 314
 315         Where files have been renamed, this will include both their
 316         current name and the name which they had in the parent tip.
 317         '''
 318
 319         ret = self._active.keys()
 320         ret.extend(x.parentname for x in self if x.is_renamed())
 321         return set(ret)
 322
 323     def comments(self):
 324         '''Return the full set of changeset comments associated with
 325         this ActiveList'''
 326
 327         return self._comments
 328
 329     def bases(self):
 330         '''Return the list of changesets that are roots of the ActiveList.
 331
 332         This is the set of active changesets where neither parent
 333         changeset is itself active.'''
 334
 335         revset = set(self.revs)
 336         return filter(lambda ctx: not [p for p in ctx.parents() if p in revset],
 337                       self.revs)
 338
 339     def tags(self):
 340         '''Find tags that refer to a changeset in the ActiveList,
 341         returning a list of 3-tuples (tag, node, is_local) for each.
 342
 343         We return all instances of a tag that refer to such a node,
 344         not just that which takes precedence.'''
 345
 346         def colliding_tags(iterable, nodes, local):
 347             for nd, name in [line.rstrip().split(' ', 1) for line in iterable]:
 348                 if nd in nodes:
 349                     yield (name, self.ws.repo.lookup(nd), local)
 350
 351         tags = []
 352         nodes = set(node.hex(ctx.node()) for ctx in self.revs)
 353
 354         if os.path.exists(self.ws.repo.join('localtags')):
 355             fh = self.ws.repo.opener('localtags')
 356             tags.extend(colliding_tags(fh, nodes, True))
 357             fh.close()
 358
 359         # We want to use the tags file from the localtip
 360         if '.hgtags' in self.localtip:
 361             data = self.localtip.filectx('.hgtags').data().splitlines()
 362             tags.extend(colliding_tags(data, nodes, False))
 363
 364         return tags
 365
 366     def prune_tags(self, data):
 367         '''Return a copy of data, which should correspond to the
 368         contents of a Mercurial tags file, with any tags that refer to
 369         changesets which are components of the ActiveList removed.'''
 370
 371         nodes = set(node.hex(ctx.node()) for ctx in self.revs)
 372         return [t for t in data if t.split(' ', 1)[0] not in nodes]
 373
 374     def _changed_file(self, path):
 375         '''Compare the parent and local versions of a given file.
 376         Return True if file changed, False otherwise.
 377
 378         Note that this compares the given path in both versions, not the given
 379         entry; renamed and copied files are compared by name, not history.
 380
 381         The fast path compares file metadata, slow path is a
 382         real comparison of file content.'''
 383
 384         if ((path in self.parenttip) != (path in self.localtip)):
 385             return True
 386
 387         parentfile = self.parenttip.filectx(path)
 388         localfile = self.localtip.filectx(path)
 389
 390         #
 391         # NB: Keep these ordered such as to make every attempt
 392         #     to short-circuit the more time consuming checks.
 393         #
 394         if parentfile.size() != localfile.size():
 395             return True
 396
 397         if parentfile.flags() != localfile.flags():
 398             return True
 399
 400         if Version.at_least("1.7"):
 401             if parentfile.cmp(localfile):
 402                 return True
 403         else:
 404             if parentfile.cmp(localfile.data()):
 405                 return True
 406
 407     def context(self, message, user):
 408         '''Return a Mercurial context object representing the entire
 409         ActiveList as one change.'''
 410         return activectx(self, message, user)
 411
 412     def as_text(self, paths):
 413         '''Return the ActiveList as a block of text in a format
 414         intended to aid debugging and simplify the test suite.
 415
 416         paths should be a list of paths for which file-level data
 417         should be included.  If it is empty, the whole active list is
 418         included.'''
 419
 420         cstr = cStringIO.StringIO()
 421
 422         cstr.write('parent tip: %s:%s\n' % (self.parenttip.rev(),
 423                                             self.parenttip))
 424         if self.localtip:
 425             rev = self.localtip.rev()
 426             cstr.write('local tip:  %s:%s\n' %
 427                        (rev is None and "working" or rev, self.localtip))
 428         else:
 429             cstr.write('local tip:  None\n')
 430
 431         cstr.write('entries:\n')
 432         for entry in self:
 433             if paths and self.ws.filepath(entry.name) not in paths:
 434                 continue
 435
 436             cstr.write('  - %s\n' % entry.name)
 437             cstr.write('    parentname: %s\n' % entry.parentname)
 438             cstr.write('    change: %s\n' % entry.change)
 439             cstr.write('    renamed: %s\n' % entry.renamed)
 440             cstr.write('    comments:\n')
 441             cstr.write('      ' + '\n      '.join(entry.comments) + '\n')
 442             cstr.write('\n')
 443
 444         return cstr.getvalue()
 445
 446
 447 class WorkList(object):
 448     '''A (user-maintained) list of files changed in this workspace as
 449     compared to any parent workspace.
 450
 451     Internally, the WorkList is stored in .hg/cdm/worklist as a list
 452     of file pathnames, one per-line.
 453
 454     This may only safely be used as a hint regarding possible
 455     modifications to the working copy, it should not be relied upon to
 456     suggest anything about committed changes.'''
 457
 458     def __init__(self, ws):
 459         '''Load the WorkList for the specified WorkSpace from disk.'''
 460
 461         self._ws = ws
 462         self._repo = ws.repo
 463         self._file = os.path.join('cdm', 'worklist')
 464         self._files = set()
 465         self._valid = False
 466
 467         if os.path.exists(self._repo.join(self._file)):
 468             self.load()
 469
 470     def __nonzero__(self):
 471         '''A WorkList object is true if it was loaded from disk,
 472         rather than freshly created.
 473         '''
 474
 475         return self._valid
 476
 477     def list(self):
 478         '''List of pathnames contained in the WorkList
 479         '''
 480
 481         return list(self._files)
 482
 483     def status(self):
 484         '''Return the status (in tuple form) of files from the
 485         WorkList as they are in the working copy
 486         '''
 487
 488         match = self._ws.matcher(files=self.list())
 489         return self._repo.status(match=match)
 490
 491     def add(self, fname):
 492         '''Add FNAME to the WorkList.
 493         '''
 494
 495         self._files.add(fname)
 496
 497     def write(self):
 498         '''Write the WorkList out to disk.
 499         '''
 500
 501         dirn = os.path.split(self._file)[0]
 502
 503         if dirn and not os.path.exists(self._repo.join(dirn)):
 504             try:
 505                 os.makedirs(self._repo.join(dirn))
 506             except EnvironmentError, e:
 507                 raise util.Abort("Couldn't create directory %s: %s" %
 508                                  (self._repo.join(dirn), e))
 509
 510         fh = self._repo.opener(self._file, 'w', atomictemp=True)
 511
 512         for name in self._files:
 513             fh.write("%s\n" % name)
 514
 515         fh.rename()
 516         fh.close()
 517
 518     def load(self):
 519         '''Read in the WorkList from disk.
 520         '''
 521
 522         fh = self._repo.opener(self._file, 'r')
 523         self._files = set(l.rstrip('\n') for l in fh)
 524         self._valid = True
 525         fh.close()
 526
 527     def delete(self):
 528         '''Empty the WorkList
 529
 530         Remove the on-disk WorkList and clear the file-list of the
 531         in-memory copy
 532         '''
 533
 534         if os.path.exists(self._repo.join(self._file)):
 535             os.unlink(self._repo.join(self._file))
 536
 537         self._files = set()
 538         self._valid = False
 539
 540
 541 class activectx(context.memctx):
 542     '''Represent an ActiveList as a Mercurial context object.
 543
 544     Part of the  WorkSpace.squishdeltas implementation.'''
 545
 546     def __init__(self, active, message, user):
 547         '''Build an activectx object.
 548
 549           active  - The ActiveList object used as the source for all data.
 550           message - Changeset description
 551           user    - Committing user'''
 552
 553         def filectxfn(repository, ctx, fname):
 554             fctx = active.localtip.filectx(fname)
 555             data = fctx.data()
 556
 557             #
 558             # .hgtags is a special case, tags referring to active list
 559             # component changesets should be elided.
 560             #
 561             if fname == '.hgtags':
 562                 data = '\n'.join(active.prune_tags(data.splitlines()))
 563
 564             return context.memfilectx(fname, data, 'l' in fctx.flags(),
 565                                       'x' in fctx.flags(),
 566                                       active[fname].parentname)
 567
 568         self.__active = active
 569         parents = (active.parenttip.node(), node.nullid)
 570         extra = {'branch': active.localtip.branch()}
 571         context.memctx.__init__(self, active.ws.repo, parents, message,
 572                                 active.files(), filectxfn, user=user,
 573                                 extra=extra)
 574
 575     def modified(self):
 576         return [entry.name for entry in self.__active if entry.is_modified()]
 577
 578     def added(self):
 579         return [entry.name for entry in self.__active if entry.is_added()]
 580
 581     def removed(self):
 582         ret = set(entry.name for entry in self.__active if entry.is_removed())
 583         ret.update(set(x.parentname for x in self.__active if x.is_renamed()))
 584         return list(ret)
 585
 586     def files(self):
 587         return self.__active.files()
 588
 589
 590 class WorkSpace(object):
 591
 592     def __init__(self, repository):
 593         self.repo = repository
 594         self.ui = self.repo.ui
 595         self.name = self.repo.root
 596
 597         self.activecache = {}
 598
 599     def parent(self, spec=None):
 600         '''Return the canonical workspace parent, either SPEC (which
 601         will be expanded) if provided or the default parent
 602         otherwise.'''
 603
 604         if spec:
 605             return self.ui.expandpath(spec)
 606
 607         p = self.ui.expandpath('default')
 608         if p == 'default':
 609             return None
 610         else:
 611             return p
 612
 613     def _localtip(self, outgoing, wctx):
 614         '''Return the most representative changeset to act as the
 615         localtip.
 616
 617         If the working directory is modified (has file changes, is a
 618         merge, or has switched branches), this will be a workingctx.
 619
 620         If the working directory is unmodified, this will be the most
 621         recent (highest revision number) local (outgoing) head on the
 622         current branch, if no heads are determined to be outgoing, it
 623         will be the most recent head on the current branch.
 624         '''
 625
 626         if (wctx.files() or len(wctx.parents()) > 1 or
 627             wctx.branch() != wctx.parents()[0].branch()):
 628             return wctx
 629
 630         heads = self.repo.heads(start=wctx.parents()[0].node())
 631         headctxs = [self.repo.changectx(n) for n in heads]
 632         localctxs = [c for c in headctxs if c.node() in outgoing]
 633
 634         ltip = sorted(localctxs or headctxs, key=lambda x: x.rev())[-1]
 635
 636         if len(heads) > 1:
 637             self.ui.warn('The current branch has more than one head, '
 638                          'using %s\n' % ltip.rev())
 639
 640         return ltip
 641
 642     def parenttip(self, heads, outgoing):
 643         '''Return the highest-numbered, non-outgoing changeset that is
 644         an ancestor of a changeset in heads.
 645
 646         This returns the most recent changeset on a given branch that
 647         is shared between a parent and child workspace, in effect the
 648         common ancestor of the chosen local tip and the parent
 649         workspace.
 650         '''
 651
 652         def tipmost_shared(head, outnodes):
 653             '''Return the changeset on the same branch as head that is
 654             not in outnodes and is closest to the tip.
 655
 656             Walk outgoing changesets from head to the bottom of the
 657             workspace (revision 0) and return the the first changeset
 658             we see that is not in outnodes.
 659
 660             If none is found (all revisions >= 0 are outgoing), the
 661             only possible parenttip is the null node (node.nullid)
 662             which is returned explicitly.
 663             '''
 664             for ctx in self._walkctxs(head, self.repo.changectx(0),
 665                                       follow=True,
 666                                       pick=lambda c: c.node() not in outnodes):
 667                 return ctx
 668
 669             return self.repo.changectx(node.nullid)
 670
 671         nodes = set(outgoing)
 672         ptips = map(lambda x: tipmost_shared(x, nodes), heads)
 673         return sorted(ptips, key=lambda x: x.rev(), reverse=True)[0]
 674
 675     def status(self, base='.', head=None, files=None):
 676         '''Translate from the hg 6-tuple status format to a hash keyed
 677         on change-type'''
 678
 679         states = ['modified', 'added', 'removed', 'deleted', 'unknown',
 680                   'ignored']
 681
 682         match = self.matcher(files=files)
 683         chngs = self.repo.status(base, head, match=match)
 684
 685         ret = {}
 686         for paths, change in zip(chngs, states):
 687             ret.update((f, change) for f in paths)
 688         return ret
 689
 690     def findoutgoing(self, parent):
 691         '''Return the base set of outgoing nodes.
 692
 693         A caching wrapper around mercurial.localrepo.findoutgoing().
 694         Complains (to the user), if the parent workspace is
 695         non-existent or inaccessible'''
 696
 697         self.ui.pushbuffer()
 698         try:
 699             try:
 700                 ui = self.ui
 701                 if hasattr(cmdutil, 'remoteui'):
 702                     ui = cmdutil.remoteui(ui, {})
 703                 pws = hg.repository(ui, parent)
 704                 if Version.at_least("1.6"):
 705                     return discovery.findoutgoing(self.repo, pws)
 706                 else:
 707                     return self.repo.findoutgoing(pws)
 708             except error.RepoError:
 709                 self.ui.warn("Warning: Parent workspace '%s' is not "
 710                              "accessible\n"
 711                              "active list will be incomplete\n\n" % parent)
 712                 return []
 713         finally:
 714             self.ui.popbuffer()
 715     findoutgoing = util.cachefunc(findoutgoing)
 716
 717     def modified(self):
 718         '''Return a list of files modified in the workspace'''
 719
 720         wctx = self.workingctx()
 721         return sorted(wctx.files() + wctx.deleted()) or None
 722
 723     def merged(self):
 724         '''Return boolean indicating whether the workspace has an uncommitted
 725         merge'''
 726
 727         wctx = self.workingctx()
 728         return len(wctx.parents()) > 1
 729
 730     def branched(self):
 731         '''Return boolean indicating whether the workspace has an
 732         uncommitted named branch'''
 733
 734         wctx = self.workingctx()
 735         return wctx.branch() != wctx.parents()[0].branch()
 736
 737     def active(self, parent=None, thorough=False):
 738         '''Return an ActiveList describing changes between workspace
 739         and parent workspace (including uncommitted changes).
 740         If the workspace has no parent, ActiveList will still describe any
 741         uncommitted changes.
 742
 743         If thorough is True use neither the WorkList nor any cached
 744         results (though the result of this call will be cached for
 745         future, non-thorough, calls).'''
 746
 747         parent = self.parent(parent)
 748
 749         #
 750         # Use the cached copy if we can (we have one, and weren't
 751         # asked to be thorough)
 752         #
 753         if not thorough and parent in self.activecache:
 754             return self.activecache[parent]
 755
 756         #
 757         # outbases: The set of outgoing nodes with no outgoing ancestors
 758         # outnodes: The full set of outgoing nodes
 759         #
 760         if parent:
 761             outbases = self.findoutgoing(parent)
 762             outnodes = self.repo.changelog.nodesbetween(outbases)[0]
 763         else:               # No parent, no outgoing nodes
 764             outbases = []
 765             outnodes = []
 766
 767         wctx = self.workingctx(worklist=not thorough)
 768         localtip = self._localtip(outnodes, wctx)
 769
 770         if localtip.rev() is None:
 771             heads = localtip.parents()
 772         else:
 773             heads = [localtip]
 774
 775         parenttip = self.parenttip(heads, outnodes)
 776
 777         #
 778         # If we couldn't find a parenttip, the two repositories must
 779         # be unrelated (Hg catches most of this, but this case is
 780         # valid for it but invalid for us)
 781         #
 782         if parenttip == None:
 783             raise util.Abort('repository is unrelated')
 784
 785         headnodes = [h.node() for h in heads]
 786         ctxs = [self.repo.changectx(n) for n in
 787                 self.repo.changelog.nodesbetween(outbases, headnodes)[0]]
 788
 789         if localtip.rev() is None:
 790             ctxs.append(localtip)
 791
 792         act = ActiveList(self, parenttip, ctxs)
 793         self.activecache[parent] = act
 794
 795         return act
 796
 797     def squishdeltas(self, active, message, user=None):
 798         '''Create a single conglomerate changeset based on a given
 799         active list.  Removes the original changesets comprising the
 800         given active list, and any tags pointing to them.
 801
 802         Operation:
 803
 804           - Commit an activectx object representing the specified
 805             active list,
 806
 807           - Remove any local tags pointing to changesets in the
 808             specified active list.
 809
 810           - Remove the changesets comprising the specified active
 811             list.
 812
 813           - Remove any metadata that may refer to changesets that were
 814             removed.
 815
 816         Calling code is expected to hold both the working copy lock
 817         and repository lock of the destination workspace
 818         '''
 819
 820         def strip_local_tags(active):
 821             '''Remove any local tags referring to the specified nodes.'''
 822
 823             if os.path.exists(self.repo.join('localtags')):
 824                 fh = None
 825                 try:
 826                     fh = self.repo.opener('localtags')
 827                     tags = active.prune_tags(fh)
 828                     fh.close()
 829
 830                     fh = self.repo.opener('localtags', 'w', atomictemp=True)
 831                     fh.writelines(tags)
 832                     fh.rename()
 833                 finally:
 834                     if fh and not fh.closed:
 835                         fh.close()
 836
 837         if active.files():
 838             for entry in active:
 839                 #
 840                 # Work around Mercurial issue #1666, if the source
 841                 # file of a rename exists in the working copy
 842                 # Mercurial will complain, and remove the file.
 843                 #
 844                 # We preemptively remove the file to avoid the
 845                 # complaint (the user was asked about this in
 846                 # cdm_recommit)
 847                 #
 848                 if entry.is_renamed():
 849                     path = self.repo.wjoin(entry.parentname)
 850                     if os.path.exists(path):
 851                         os.unlink(path)
 852
 853             self.repo.commitctx(active.context(message, user))
 854             wsstate = "recommitted"
 855             destination = self.repo.changelog.tip()
 856         else:
 857             #
 858             # If all we're doing is stripping the old nodes, we want to
 859             # update the working copy such that we're not at a revision
 860             # that's about to go away.
 861             #
 862             wsstate = "tip"
 863             destination = active.parenttip.node()
 864
 865         self.clean(destination)
 866
 867         #
 868         # Tags were elided by the activectx object.  Local tags,
 869         # however, must be removed manually.
 870         #
 871         try:
 872             strip_local_tags(active)
 873         except EnvironmentError, e:
 874             raise util.Abort('Could not recommit tags: %s\n' % e)
 875
 876         # Silence all the strip and update fun
 877         self.ui.pushbuffer()
 878
 879         #
 880         # Remove the previous child-local changes by stripping the
 881         # nodes that form the base of the ActiveList (removing their
 882         # children in the process).
 883         #
 884         try:
 885             try:
 886                 for base in active.bases():
 887                     #
 888                     # Any cached information about the repository is
 889                     # likely to be invalid during the strip.  The
 890                     # caching of branch tags is especially
 891                     # problematic.
 892                     #
 893                     self.repo.invalidate()
 894                     repair.strip(self.ui, self.repo, base.node(), backup=False)
 895             except:
 896                 #
 897                 # If this fails, it may leave us in a surprising place in
 898                 # the history.
 899                 #
 900                 # We want to warn the user that something went wrong,
 901                 # and what will happen next, re-raise the exception, and
 902                 # bring the working copy back into a consistent state
 903                 # (which the finally block will do)
 904                 #
 905                 self.ui.warn("stripping failed, your workspace will have "
 906                              "superfluous heads.\n"
 907                              "your workspace has been updated to the "
 908                              "%s changeset.\n" % wsstate)
 909                 raise               # Re-raise the exception
 910         finally:
 911             self.clean()
 912             self.repo.dirstate.write() # Flush the dirstate
 913             self.repo.invalidate()     # Invalidate caches
 914
 915             #
 916             # We need to remove Hg's undo information (used for rollback),
 917             # since it refers to data that will probably not exist after
 918             # the strip.
 919             #
 920             if os.path.exists(self.repo.sjoin('undo')):
 921                 try:
 922                     os.unlink(self.repo.sjoin('undo'))
 923                 except EnvironmentError, e:
 924                     raise util.Abort('failed to remove undo data: %s\n' % e)
 925
 926             self.ui.popbuffer()
 927
 928     def filepath(self, path):
 929         'Return the full path to a workspace file.'
 930
 931         return self.repo.pathto(path)
 932
 933     def clean(self, rev=None):
 934         '''Bring workspace up to REV (or tip) forcefully (discarding in
 935         progress changes)'''
 936
 937         if rev != None:
 938             rev = self.repo.lookup(rev)
 939         else:
 940             rev = self.repo.changelog.tip()
 941
 942         hg.clean(self.repo, rev, show_stats=False)
 943
 944     def mq_applied(self):
 945         '''True if the workspace has Mq patches applied'''
 946
 947         q = mq.queue(self.ui, self.repo.join(''))
 948         return q.applied
 949
 950     def workingctx(self, worklist=False):
 951         '''Return a workingctx object representing the working copy.
 952
 953         If worklist is true, return a workingctx object created based
 954         on the status of files in the workspace's worklist.'''
 955
 956         wl = WorkList(self)
 957
 958         if worklist and wl:
 959             return context.workingctx(self.repo, changes=wl.status())
 960         else:
 961             return self.repo.changectx(None)
 962
 963     def matcher(self, pats=None, opts=None, files=None):
 964         '''Return a match object suitable for Mercurial based on
 965         specified criteria.
 966
 967         If files is specified it is a list of pathnames relative to
 968         the repository root to be matched precisely.
 969
 970         If pats and/or opts are specified, these are as to
 971         cmdutil.match'''
 972
 973         of_patterns = pats is not None or opts is not None
 974         of_files = files is not None
 975         opts = opts or {}       # must be a dict
 976
 977         assert not (of_patterns and of_files)
 978
 979         if of_patterns:
 980             return cmdutil.match(self.repo, pats, opts)
 981         elif of_files:
 982             return cmdutil.matchfiles(self.repo, files)
 983         else:
 984             return cmdutil.matchall(self.repo)
 985
 986     def diff(self, node1=None, node2=None, match=None, opts=None):
 987         '''Return the diff of changes between two changesets as a string'''
 988
 989         #
 990         # Retain compatibility by only calling diffopts() if it
 991         # obviously has not already been done.
 992         #
 993         if isinstance(opts, dict):
 994             opts = patch.diffopts(self.ui, opts)
 995
 996         ret = cStringIO.StringIO()
 997         for chunk in patch.diff(self.repo, node1, node2, match=match,
 998                                 opts=opts):
 999             ret.write(chunk)
1000
1001         return ret.getvalue()
1002
1003     if Version.at_least("1.6"):
1004         def copy(self, src, dest):
1005             '''Copy a file from src to dest
1006             '''
1007
1008             self.workingctx().copy(src, dest)
1009     else:
1010         def copy(self, src, dest):
1011             '''Copy a file from src to dest
1012             '''
1013
1014             self.repo.copy(src, dest)
1015
1016
1017     if Version.at_least("1.4"):
1018
1019         def _walkctxs(self, base, head, follow=False, pick=None):
1020             '''Generate changectxs between BASE and HEAD.
1021
1022             Walk changesets between BASE and HEAD (in the order implied by
1023             their relation), following a given branch if FOLLOW is a true
1024             value, yielding changectxs where PICK (if specified) returns a
1025             true value.
1026
1027             PICK is a function of one argument, a changectx.'''
1028
1029             chosen = {}
1030
1031             def prep(ctx, fns):
1032                 chosen[ctx.rev()] = not pick or pick(ctx)
1033
1034             opts = {'rev': ['%s:%s' % (base.rev(), head.rev())],
1035                     'follow': follow}
1036             matcher = cmdutil.matchall(self.repo)
1037
1038             for ctx in cmdutil.walkchangerevs(self.repo, matcher, opts, prep):
1039                 if chosen[ctx.rev()]:
1040                     yield ctx
1041     else:
1042
1043         def _walkctxs(self, base, head, follow=False, pick=None):
1044             '''Generate changectxs between BASE and HEAD.
1045
1046             Walk changesets between BASE and HEAD (in the order implied by
1047             their relation), following a given branch if FOLLOW is a true
1048             value, yielding changectxs where PICK (if specified) returns a
1049             true value.
1050
1051             PICK is a function of one argument, a changectx.'''
1052
1053             opts = {'rev': ['%s:%s' % (base.rev(), head.rev())],
1054                     'follow': follow}
1055
1056             changectx = self.repo.changectx
1057             getcset = util.cachefunc(lambda r: changectx(r).changeset())
1058
1059             #
1060             # See the docstring of mercurial.cmdutil.walkchangerevs() for
1061             # the phased approach to the iterator returned.  The important
1062             # part to note is that the 'add' phase gathers nodes, which
1063             # the 'iter' phase then iterates through.
1064             #
1065             changeiter = cmdutil.walkchangerevs(self.ui, self.repo,
1066                                                 [], getcset, opts)[0]
1067
1068             matched = {}
1069             for st, rev, fns in changeiter:
1070                 if st == 'add':
1071                     ctx = changectx(rev)
1072                     if not pick or pick(ctx):
1073                         matched[rev] = ctx
1074                 elif st == 'iter':
1075                     if rev in matched:
1076                         yield matched[rev]