~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/annotate.py

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

• reverse the comparison (4183.7.1 to 4597.3.73)
• stop comparing with revision 4597.3.73

Show diffs side-by-side

added

removed

bzrlib/annotate.py

1

 

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

 

1

# Copyright (C) 2004, 2005, 2006, 2007 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 file's annotations into command line UI ready tuples.

 

176

    """Expand a a files 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().

195

191

        graph = repository.get_graph()

196

192

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

197

193

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

256

252

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

257

253

        the SequenceMatcher.get_matching_blocks format

258

254

        (start_left, start_right, length_of_match).

259

 

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

 

255

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

260

256

        if any revision ids are children of others.

261

257

        If None, then any ancestry disputes will be resolved with

262

258

        new_revision_id

317

313

    return matcher.get_matching_blocks()

318

314

 

319

315

 

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

 

 

343

316

def _find_matching_unannotated_lines(output_lines, plain_child_lines,

344

317

                                     child_lines, start_child, end_child,

345

318

                                     right_lines, start_right, end_right,

350

323

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

351

324

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

352

325

        for the left parent

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

 

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

358

330

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

359

331

        parent

360

332

    :param start_right: Position in right_lines to start the match

396

368

                    if len(heads) == 1:

397

369

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

398

370

                    else:

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]))

 

371

                        # Both claim different origins, sort lexicographically

 

372

                        # so that we always get a stable result.

 

373

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

408

374

        last_child_idx = child_idx + match_len

409

375

 

410

376

 

434

400

    matching_left_and_right = _get_matching_blocks(right_parent_lines,

435

401

                                                   annotated_lines)

436

402

    for right_idx, left_idx, match_len in matching_left_and_right:

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

 

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

440

407

        if last_right_idx == right_idx or last_left_idx == left_idx:

441

408

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

442

409

            lines_extend(annotated_lines[last_left_idx:left_idx])

454

421

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

455

422

        lines_extend(annotated_lines[left_idx:left_idx + match_len])

456

423

    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