~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/annotate.py

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

• reverse the comparison (5255.1.1 to 3735.40.19)
• stop comparing with revision 3735.40.19

Show diffs side-by-side

added

removed

bzrlib/annotate.py

1

 

# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd

 

1

# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

173

173

 

174

174

 

175

175

def _expand_annotations(annotations, branch, current_rev=None):

176

 

    """Expand a a files annotations into command line UI ready tuples.

 

176

    """Expand a file's annotations into command line UI ready tuples.

177

177

 

178

178

    Each tuple includes detailed information, such as the author name, and date

179

179

    string for the commit, rather than just the revision id.

188

188

        # or something.

189

189

        last_revision = current_rev.revision_id

190

190

        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.

 

191

        # XXX: The main difficulty is that we need to inject a single new node

 

192

        #      (current_rev) into the graph before it gets numbered, etc.

 

193

        #      Once KnownGraph gets an 'add_node()' function, we can use

 

194

        #      VF.get_known_graph_ancestry().

191

195

        graph = repository.get_graph()

192

196

        revision_graph = dict(((key, value) for key, value in

193

197

            graph.iter_ancestry(current_rev.parent_ids) if value is not None))

252

256

        between the text and its left-hand-parent.  The format is

253

257

        the SequenceMatcher.get_matching_blocks format

254

258

        (start_left, start_right, length_of_match).

255

 

    :param heads_provider: An object which provids a .heads() call to resolve

 

259

    :param heads_provider: An object which provides a .heads() call to resolve

256

260

        if any revision ids are children of others.

257

261

        If None, then any ancestry disputes will be resolved with

258

262

        new_revision_id

313

317

    return matcher.get_matching_blocks()

314

318

 

315

319

 

 

320

_break_annotation_tie = None

 

321

 

 

322

def _old_break_annotation_tie(annotated_lines):

 

323

    """Chose an attribution between several possible ones.

 

324

 

 

325

    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where

 

326

        the lines are identical but the revids different while no parent

 

327

        relation exist between them

 

328

 

 

329

     :return : The "winning" line. This must be one with a revid that

 

330

         guarantees that further criss-cross merges will converge. Failing to

 

331

         do so have performance implications.

 

332

    """

 

333

    # sort lexicographically so that we always get a stable result.

 

334

 

 

335

    # TODO: while 'sort' is the easiest (and nearly the only possible solution)

 

336

    # with the current implementation, chosing the oldest revision is known to

 

337

    # provide better results (as in matching user expectations). The most

 

338

    # common use case being manual cherry-pick from an already existing

 

339

    # revision.

 

340

    return sorted(annotated_lines)[0]

 

341

 

 

342

 

316

343

def _find_matching_unannotated_lines(output_lines, plain_child_lines,

317

344

                                     child_lines, start_child, end_child,

318

345

                                     right_lines, start_right, end_right,

323

350

    :param plain_child_lines: The unannotated new lines for the child text

324

351

    :param child_lines: Lines for the child text which have been annotated

325

352

        for the left parent

326

 

    :param start_child: Position in plain_child_lines and child_lines to start the

327

 

        match searching

328

 

    :param end_child: Last position in plain_child_lines and child_lines to search

329

 

        for a match

 

353

 

 

354

    :param start_child: Position in plain_child_lines and child_lines to start

 

355

        the match searching

 

356

    :param end_child: Last position in plain_child_lines and child_lines to

 

357

        search for a match

330

358

    :param right_lines: The annotated lines for the whole text for the right

331

359

        parent

332

360

    :param start_right: Position in right_lines to start the match

368

396

                    if len(heads) == 1:

369

397

                        output_append((iter(heads).next(), left[1]))

370

398

                    else:

371

 

                        # Both claim different origins, sort lexicographically

372

 

                        # so that we always get a stable result.

373

 

                        output_append(sorted([left, right])[0])

 

399

                        # Both claim different origins, get a stable result.

 

400

                        # If the result is not stable, there is a risk a

 

401

                        # performance degradation as criss-cross merges will

 

402

                        # flip-flop the attribution.

 

403

                        if _break_annotation_tie is None:

 

404

                            output_append(

 

405

                                _old_break_annotation_tie([left, right]))

 

406

                        else:

 

407

                            output_append(_break_annotation_tie([left, right]))

374

408

        last_child_idx = child_idx + match_len

375

409

 

376

410

 

400

434

    matching_left_and_right = _get_matching_blocks(right_parent_lines,

401

435

                                                   annotated_lines)

402

436

    for right_idx, left_idx, match_len in matching_left_and_right:

403

 

        # annotated lines from last_left_idx to left_idx did not match the lines from

404

 

        # last_right_idx

405

 

        # to right_idx, the raw lines should be compared to determine what annotations

406

 

        # need to be updated

 

437

        # annotated lines from last_left_idx to left_idx did not match the

 

438

        # lines from last_right_idx to right_idx, the raw lines should be

 

439

        # compared to determine what annotations need to be updated

407

440

        if last_right_idx == right_idx or last_left_idx == left_idx:

408

441

            # One of the sides is empty, so this is a pure insertion

409

442

            lines_extend(annotated_lines[last_left_idx:left_idx])

421

454

        # If left and right agree on a range, just push that into the output

422

455

        lines_extend(annotated_lines[left_idx:left_idx + match_len])

423

456

    return lines

 

457

 

 

458

 

 

459

try:

 

460

    from bzrlib._annotator_pyx import Annotator

 

461

except ImportError, e:

 

462

    osutils.failed_to_load_extension(e)

 

463

    from bzrlib._annotator_py import Annotator

• Older »

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