~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/annotate.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-06-10 08:15:19 UTC
  • mfrom: (3489.1.2 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080610081519-95unlj6ayptlh2uv
(mbp) Bump version to 1.6b3

Show diffs side-by-side

added added

removed removed

Lines of Context:
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""File annotate based on weave storage"""
18
18
 
19
19
# TODO: Choice of more or less verbose formats:
20
 
#
 
20
21
21
# interposed: show more details between blocks of modified lines
22
22
 
23
23
# TODO: Show which revision caused a line to merge into the parent
24
24
 
25
25
# TODO: perhaps abbreviate timescales depending on how recent they are
26
 
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.
 
26
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.  
27
27
 
28
28
import sys
29
29
import time
35
35
    tsort,
36
36
    )
37
37
from bzrlib.config import extract_email_address
38
 
from bzrlib.repository import _strip_NULL_ghosts
39
 
from bzrlib.revision import CURRENT_REVISION, Revision
40
38
 
41
39
 
42
40
def annotate_file(branch, rev_id, file_id, verbose=False, full=False,
59
57
        to_file = sys.stdout
60
58
 
61
59
    # Handle the show_ids case
62
 
    annotations = _annotations(branch.repository, file_id, rev_id)
 
60
    last_rev_id = None
63
61
    if show_ids:
64
 
        return _show_id_annotations(annotations, to_file, full)
 
62
        annotations = _annotations(branch.repository, file_id, rev_id)
 
63
        max_origin_len = max(len(origin) for origin, text in annotations)
 
64
        for origin, text in annotations:
 
65
            if full or last_rev_id != origin:
 
66
                this = origin
 
67
            else:
 
68
                this = ''
 
69
            to_file.write('%*s | %s' % (max_origin_len, this, text))
 
70
            last_rev_id = origin
 
71
        return
65
72
 
66
73
    # Calculate the lengths of the various columns
67
 
    annotation = list(_expand_annotations(annotations, branch))
68
 
    _print_annotations(annotation, verbose, to_file, full)
69
 
 
70
 
 
71
 
def annotate_file_tree(tree, file_id, to_file, verbose=False, full=False,
72
 
    show_ids=False):
73
 
    """Annotate file_id in a tree.
74
 
 
75
 
    The tree should already be read_locked() when annotate_file_tree is called.
76
 
 
77
 
    :param tree: The tree to look for revision numbers and history from.
78
 
    :param file_id: The file_id to annotate.
79
 
    :param to_file: The file to output the annotation to.
80
 
    :param verbose: Show all details rather than truncating to ensure
81
 
        reasonable text width.
82
 
    :param full: XXXX Not sure what this does.
83
 
    :param show_ids: Show revision ids in the annotation output.
84
 
    """
85
 
    rev_id = tree.last_revision()
86
 
    branch = tree.branch
87
 
 
88
 
    # Handle the show_ids case
89
 
    annotations = list(tree.annotate_iter(file_id))
90
 
    if show_ids:
91
 
        return _show_id_annotations(annotations, to_file, full)
92
 
 
93
 
    # Create a virtual revision to represent the current tree state.
94
 
    # Should get some more pending commit attributes, like pending tags,
95
 
    # bugfixes etc.
96
 
    current_rev = Revision(CURRENT_REVISION)
97
 
    current_rev.parent_ids = tree.get_parent_ids()
98
 
    current_rev.committer = tree.branch.get_config().username()
99
 
    current_rev.message = "?"
100
 
    current_rev.timestamp = round(time.time(), 3)
101
 
    current_rev.timezone = osutils.local_time_offset()
102
 
    annotation = list(_expand_annotations(annotations, tree.branch,
103
 
        current_rev))
104
 
    _print_annotations(annotation, verbose, to_file, full)
105
 
 
106
 
 
107
 
def _print_annotations(annotation, verbose, to_file, full):
108
 
    """Print annotations to to_file.
109
 
 
110
 
    :param to_file: The file to output the annotation to.
111
 
    :param verbose: Show all details rather than truncating to ensure
112
 
        reasonable text width.
113
 
    :param full: XXXX Not sure what this does.
114
 
    """
 
74
    annotation = list(_annotate_file(branch, rev_id, file_id))
115
75
    if len(annotation) == 0:
116
76
        max_origin_len = max_revno_len = max_revid_len = 0
117
77
    else:
150
110
        prevanno = anno
151
111
 
152
112
 
153
 
def _show_id_annotations(annotations, to_file, full):
154
 
    if not annotations:
155
 
        return
156
 
    last_rev_id = None
157
 
    max_origin_len = max(len(origin) for origin, text in annotations)
158
 
    for origin, text in annotations:
159
 
        if full or last_rev_id != origin:
160
 
            this = origin
161
 
        else:
162
 
            this = ''
163
 
        to_file.write('%*s | %s' % (max_origin_len, this, text))
164
 
        last_rev_id = origin
165
 
    return
166
 
 
167
 
 
168
113
def _annotations(repo, file_id, rev_id):
169
 
    """Return the list of (origin_revision_id, line_text) for a revision of a file in a repository."""
170
 
    annotations = repo.texts.annotate((file_id, rev_id))
171
 
    #
172
 
    return [(key[-1], line) for (key, line) in annotations]
173
 
 
174
 
 
175
 
def _expand_annotations(annotations, branch, current_rev=None):
176
 
    """Expand a file's annotations into command line UI ready tuples.
177
 
 
178
 
    Each tuple includes detailed information, such as the author name, and date
179
 
    string for the commit, rather than just the revision id.
180
 
 
181
 
    :param annotations: The annotations to expand.
182
 
    :param revision_id_to_revno: A map from id to revision numbers.
183
 
    :param branch: A locked branch to query for revision details.
 
114
    """Return the list of (origin,text) for a revision of a file in a repository."""
 
115
    w = repo.weave_store.get_weave(file_id, repo.get_transaction())
 
116
    return w.annotate(rev_id)
 
117
 
 
118
 
 
119
def _annotate_file(branch, rev_id, file_id):
 
120
    """Yield the origins for each line of a file.
 
121
 
 
122
    This includes detailed information, such as the author name, and
 
123
    date string for the commit, rather than just the revision id.
184
124
    """
185
 
    repository = branch.repository
186
 
    if current_rev is not None:
187
 
        # This can probably become a function on MutableTree, get_revno_map there,
188
 
        # or something.
189
 
        last_revision = current_rev.revision_id
190
 
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
191
 
        graph = repository.get_graph()
192
 
        revision_graph = dict(((key, value) for key, value in
193
 
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
194
 
        revision_graph = _strip_NULL_ghosts(revision_graph)
195
 
        revision_graph[last_revision] = current_rev.parent_ids
196
 
        merge_sorted_revisions = tsort.merge_sort(
197
 
            revision_graph,
198
 
            last_revision,
199
 
            None,
200
 
            generate_revno=True)
201
 
        revision_id_to_revno = dict((rev_id, revno)
202
 
            for seq_num, rev_id, depth, revno, end_of_merge in
203
 
                merge_sorted_revisions)
204
 
    else:
205
 
        revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
125
    revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
126
    annotations = _annotations(branch.repository, file_id, rev_id)
206
127
    last_origin = None
207
128
    revision_ids = set(o for o, t in annotations)
208
 
    revisions = {}
209
 
    if CURRENT_REVISION in revision_ids:
210
 
        revision_id_to_revno[CURRENT_REVISION] = (
211
 
            "%d?" % (branch.revno() + 1),)
212
 
        revisions[CURRENT_REVISION] = current_rev
213
 
    revision_ids = [o for o in revision_ids if
214
 
                    repository.has_revision(o)]
215
 
    revisions.update((r.revision_id, r) for r in
216
 
                     repository.get_revisions(revision_ids))
 
129
    revision_ids = [o for o in revision_ids if 
 
130
                    branch.repository.has_revision(o)]
 
131
    revisions = dict((r.revision_id, r) for r in 
 
132
                     branch.repository.get_revisions(revision_ids))
217
133
    for origin, text in annotations:
218
134
        text = text.rstrip('\r\n')
219
135
        if origin == last_origin:
231
147
                                     time.gmtime(rev.timestamp + tz))
232
148
            # a lazy way to get something like the email address
233
149
            # TODO: Get real email address
234
 
            author = rev.get_apparent_authors()[0]
 
150
            author = rev.get_apparent_author()
235
151
            try:
236
152
                author = extract_email_address(author)
237
153
            except errors.NoEmailInUsername:
243
159
               _left_matching_blocks=None,
244
160
               heads_provider=None):
245
161
    """Create a new annotated version from new lines and parent annotations.
246
 
 
 
162
    
247
163
    :param parents_lines: List of annotated lines for all parents
248
164
    :param new_lines: The un-annotated new lines
249
165
    :param new_revision_id: The revision-id to associate with new lines
252
168
        between the text and its left-hand-parent.  The format is
253
169
        the SequenceMatcher.get_matching_blocks format
254
170
        (start_left, start_right, length_of_match).
255
 
    :param heads_provider: An object which provides a .heads() call to resolve
 
171
    :param heads_provider: An object which provids a .heads() call to resolve
256
172
        if any revision ids are children of others.
257
173
        If None, then any ancestry disputes will be resolved with
258
174
        new_revision_id
368
284
                    if len(heads) == 1:
369
285
                        output_append((iter(heads).next(), left[1]))
370
286
                    else:
371
 
                        # Both claim different origins, sort lexicographically
372
 
                        # so that we always get a stable result.
373
 
                        output_append(sorted([left, right])[0])
 
287
                        # Both claim different origins
 
288
                        output_append((revision_id, left[1]))
 
289
                        # We know that revision_id is the head for
 
290
                        # left and right, so cache it
 
291
                        heads_provider.cache(
 
292
                            (revision_id, left[0]),
 
293
                            (revision_id,))
 
294
                        heads_provider.cache(
 
295
                            (revision_id, right[0]),
 
296
                            (revision_id,))
374
297
        last_child_idx = child_idx + match_len
375
298
 
376
299