~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

• browse files at revision 5190.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 5190.1.1

• reverse the comparison (5190.1.1 to 6170)
• stop comparing with revision 6170

Show diffs side-by-side

added

removed

bzrlib/revisionspec.py

15

15

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

16

16

 

17

17

 

 

18

import re

 

19

 

18

20

from bzrlib.lazy_import import lazy_import

19

21

lazy_import(globals(), """

20

22

import bisect

21

23

import datetime

 

24

""")

22

25

 

23

26

from bzrlib import (

24

 

    branch as _mod_branch,

 

27

    errors,

25

28

    osutils,

 

29

    registry,

26

30

    revision,

27

31

    symbol_versioning,

28

 

    workingtree,

29

 

    )

30

 

from bzrlib.i18n import gettext

31

 

""")

32

 

 

33

 

from bzrlib import (

34

 

    errors,

35

 

    lazy_regex,

36

 

    registry,

37

32

    trace,

38

33

    )

39

34

 

118

113

        return RevisionInfo(branch, revno, revision_id)

119

114

 

120

115

 

 

116

_revno_regex = None

 

117

 

 

118

 

121

119

class RevisionSpec(object):

122

120

    """A parsed revision specification."""

123

121

 

168

166

                         spectype.__name__, spec)

169

167

            return spectype(spec, _internal=True)

170

168

        else:

 

169

            for spectype in SPEC_TYPES:

 

170

                if spec.startswith(spectype.prefix):

 

171

                    trace.mutter('Returning RevisionSpec %s for %s',

 

172

                                 spectype.__name__, spec)

 

173

                    return spectype(spec, _internal=True)

171

174

            # Otherwise treat it as a DWIM, build the RevisionSpec object and

172

175

            # wait for _match_on to be called.

173

176

            return RevisionSpec_dwim(spec, _internal=True)

299

302

    # each revspec we try.

300

303

    wants_revision_history = False

301

304

 

302

 

    _revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')

303

 

 

304

 

    # The revspecs to try

305

 

    _possible_revspecs = []

306

 

 

307

305

    def _try_spectype(self, rstype, branch):

308

306

        rs = rstype(self.spec, _internal=True)

309

307

        # Hit in_history to find out if it exists, or we need to try the

314

312

        """Run the lookup and see what we can get."""

315

313

 

316

314

        # First, see if it's a revno

317

 

        if self._revno_regex.match(self.spec) is not None:

 

315

        global _revno_regex

 

316

        if _revno_regex is None:

 

317

            _revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')

 

318

        if _revno_regex.match(self.spec) is not None:

318

319

            try:

319

320

                return self._try_spectype(RevisionSpec_revno, branch)

320

321

            except RevisionSpec_revno.dwim_catchable_exceptions:

321

322

                pass

322

323

 

323

324

        # Next see what has been registered

324

 

        for objgetter in self._possible_revspecs:

325

 

            rs_class = objgetter.get_obj()

326

 

            try:

327

 

                return self._try_spectype(rs_class, branch)

328

 

            except rs_class.dwim_catchable_exceptions:

329

 

                pass

330

 

 

331

 

        # Try the old (deprecated) dwim list:

332

325

        for rs_class in dwim_revspecs:

333

326

            try:

334

327

                return self._try_spectype(rs_class, branch)

340

333

        # really relevant.

341

334

        raise errors.InvalidRevisionSpec(self.spec, branch)

342

335

 

343

 

    @classmethod

344

 

    def append_possible_revspec(cls, revspec):

345

 

        """Append a possible DWIM revspec.

346

 

 

347

 

        :param revspec: Revision spec to try.

348

 

        """

349

 

        cls._possible_revspecs.append(registry._ObjectGetter(revspec))

350

 

 

351

 

    @classmethod

352

 

    def append_possible_lazy_revspec(cls, module_name, member_name):

353

 

        """Append a possible lazily loaded DWIM revspec.

354

 

 

355

 

        :param module_name: Name of the module with the revspec

356

 

        :param member_name: Name of the revspec within the module

357

 

        """

358

 

        cls._possible_revspecs.append(

359

 

            registry._LazyObjectGetter(module_name, member_name))

360

 

 

361

336

 

362

337

class RevisionSpec_revno(RevisionSpec):

363

338

    """Selects a revision using a number."""

469

444

 

470

445

 

471

446

 

472

 

class RevisionIDSpec(RevisionSpec):

473

 

 

474

 

    def _match_on(self, branch, revs):

475

 

        revision_id = self.as_revision_id(branch)

476

 

        return RevisionInfo.from_revision_id(branch, revision_id, revs)

477

 

 

478

 

 

479

 

class RevisionSpec_revid(RevisionIDSpec):

 

447

class RevisionSpec_revid(RevisionSpec):

480

448

    """Selects a revision using the revision id."""

481

449

 

482

450

    help_txt = """Selects a revision using the revision id.

491

459

 

492

460

    prefix = 'revid:'

493

461

 

494

 

    def _as_revision_id(self, context_branch):

 

462

    def _match_on(self, branch, revs):

495

463

        # self.spec comes straight from parsing the command line arguments,

496

464

        # so we expect it to be a Unicode string. Switch it to the internal

497

465

        # representation.

 

466

        revision_id = osutils.safe_revision_id(self.spec, warn=False)

 

467

        return RevisionInfo.from_revision_id(branch, revision_id, revs)

 

468

 

 

469

    def _as_revision_id(self, context_branch):

498

470

        return osutils.safe_revision_id(self.spec, warn=False)

499

471

 

500

472

 

686

658

                                   August 14th, 2006 at 5:10pm.

687

659

    """

688

660

    prefix = 'date:'

689

 

    _date_regex = lazy_regex.lazy_compile(

 

661

    _date_re = re.compile(

690

662

            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'

691

663

            r'(,|T)?\s*'

692

664

            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'

710

682

        elif self.spec.lower() == 'tomorrow':

711

683

            dt = today + datetime.timedelta(days=1)

712

684

        else:

713

 

            m = self._date_regex.match(self.spec)

 

685

            m = self._date_re.match(self.spec)

714

686

            if not m or (not m.group('date') and not m.group('time')):

715

687

                raise errors.InvalidRevisionSpec(self.user_spec,

716

688

                                                 branch, 'invalid date')

841

813

        revision_b = other_branch.last_revision()

842

814

        if revision_b in (None, revision.NULL_REVISION):

843

815

            raise errors.NoCommits(other_branch)

844

 

        if branch is None:

845

 

            branch = other_branch

846

 

        else:

847

 

            try:

848

 

                # pull in the remote revisions so we can diff

849

 

                branch.fetch(other_branch, revision_b)

850

 

            except errors.ReadOnlyError:

851

 

                branch = other_branch

 

816

        # pull in the remote revisions so we can diff

 

817

        branch.fetch(other_branch, revision_b)

852

818

        try:

853

819

            revno = branch.revision_id_to_revno(revision_b)

854

820

        except errors.NoSuchRevision:

874

840

            raise errors.NoCommits(other_branch)

875

841

        return other_branch.repository.revision_tree(last_revision)

876

842

 

877

 

    def needs_branch(self):

878

 

        return False

879

 

 

880

 

    def get_branch(self):

881

 

        return self.spec

882

 

 

883

843

 

884

844

 

885

845

class RevisionSpec_submit(RevisionSpec_ancestor):

911

871

            location_type = 'parent branch'

912

872

        if submit_location is None:

913

873

            raise errors.NoSubmitBranch(branch)

914

 

        trace.note(gettext('Using {0} {1}').format(location_type,

915

 

                                                        submit_location))

 

874

        trace.note('Using %s %s', location_type, submit_location)

916

875

        return submit_location

917

876

 

918

877

    def _match_on(self, branch, revs):

925

884

            self._get_submit_location(context_branch))

926

885

 

927

886

 

928

 

class RevisionSpec_annotate(RevisionIDSpec):

929

 

 

930

 

    prefix = 'annotate:'

931

 

 

932

 

    help_txt = """Select the revision that last modified the specified line.

933

 

 

934

 

    Select the revision that last modified the specified line.  Line is

935

 

    specified as path:number.  Path is a relative path to the file.  Numbers

936

 

    start at 1, and are relative to the current version, not the last-

937

 

    committed version of the file.

938

 

    """

939

 

 

940

 

    def _raise_invalid(self, numstring, context_branch):

941

 

        raise errors.InvalidRevisionSpec(self.user_spec, context_branch,

942

 

            'No such line: %s' % numstring)

943

 

 

944

 

    def _as_revision_id(self, context_branch):

945

 

        path, numstring = self.spec.rsplit(':', 1)

946

 

        try:

947

 

            index = int(numstring) - 1

948

 

        except ValueError:

949

 

            self._raise_invalid(numstring, context_branch)

950

 

        tree, file_path = workingtree.WorkingTree.open_containing(path)

951

 

        tree.lock_read()

952

 

        try:

953

 

            file_id = tree.path2id(file_path)

954

 

            if file_id is None:

955

 

                raise errors.InvalidRevisionSpec(self.user_spec,

956

 

                    context_branch, "File '%s' is not versioned." %

957

 

                    file_path)

958

 

            revision_ids = [r for (r, l) in tree.annotate_iter(file_id)]

959

 

        finally:

960

 

            tree.unlock()

961

 

        try:

962

 

            revision_id = revision_ids[index]

963

 

        except IndexError:

964

 

            self._raise_invalid(numstring, context_branch)

965

 

        if revision_id == revision.CURRENT_REVISION:

966

 

            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,

967

 

                'Line %s has not been committed.' % numstring)

968

 

        return revision_id

969

 

 

970

 

 

971

 

class RevisionSpec_mainline(RevisionIDSpec):

972

 

 

973

 

    help_txt = """Select mainline revision that merged the specified revision.

974

 

 

975

 

    Select the revision that merged the specified revision into mainline.

976

 

    """

977

 

 

978

 

    prefix = 'mainline:'

979

 

 

980

 

    def _as_revision_id(self, context_branch):

981

 

        revspec = RevisionSpec.from_string(self.spec)

982

 

        if revspec.get_branch() is None:

983

 

            spec_branch = context_branch

984

 

        else:

985

 

            spec_branch = _mod_branch.Branch.open(revspec.get_branch())

986

 

        revision_id = revspec.as_revision_id(spec_branch)

987

 

        graph = context_branch.repository.get_graph()

988

 

        result = graph.find_lefthand_merger(revision_id,

989

 

                                            context_branch.last_revision())

990

 

        if result is None:

991

 

            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)

992

 

        return result

993

 

 

994

 

 

995

887

# The order in which we want to DWIM a revision spec without any prefix.

996

888

# revno is always tried first and isn't listed here, this is used by

997

889

# RevisionSpec_dwim._match_on

998

 

dwim_revspecs = symbol_versioning.deprecated_list(

999

 

    symbol_versioning.deprecated_in((2, 4, 0)), "dwim_revspecs", [])

 

890

dwim_revspecs = [

 

891

    RevisionSpec_tag, # Let's try for a tag

 

892

    RevisionSpec_revid, # Maybe it's a revid?

 

893

    RevisionSpec_date, # Perhaps a date?

 

894

    RevisionSpec_branch, # OK, last try, maybe it's a branch

 

895

    ]

1000

896

 

1001

 

RevisionSpec_dwim.append_possible_revspec(RevisionSpec_tag)

1002

 

RevisionSpec_dwim.append_possible_revspec(RevisionSpec_revid)

1003

 

RevisionSpec_dwim.append_possible_revspec(RevisionSpec_date)

1004

 

RevisionSpec_dwim.append_possible_revspec(RevisionSpec_branch)

1005

897

 

1006

898

revspec_registry = registry.Registry()

1007

899

def _register_revspec(revspec):

1016

908

_register_revspec(RevisionSpec_ancestor)

1017

909

_register_revspec(RevisionSpec_branch)

1018

910

_register_revspec(RevisionSpec_submit)

1019

 

_register_revspec(RevisionSpec_annotate)

1020

 

_register_revspec(RevisionSpec_mainline)

 

911

 

 

912

# classes in this list should have a "prefix" attribute, against which

 

913

# string specs are matched

 

914

SPEC_TYPES = symbol_versioning.deprecated_list(

 

915

    symbol_versioning.deprecated_in((1, 12, 0)), "SPEC_TYPES", [])

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1