/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Andrew Bennetts
  • Date: 2009-06-03 04:42:02 UTC
  • mfrom: (4399 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4401.
  • Revision ID: andrew.bennetts@canonical.com-20090603044202-bq5pwfme4fve3xbt
Merge, resolving NEWS conflict.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
610
610
                for glob, paths in ignored.items():
611
611
                    match_len += len(paths)
612
612
                self.outf.write("ignored %d file(s).\n" % match_len)
613
 
            self.outf.write("If you wish to add some of these files,"
614
 
                            " please add them by name.\n")
 
613
            self.outf.write("If you wish to add ignored files, "
 
614
                            "please add them explicitly by name. "
 
615
                            "(\"bzr ignored\" gives a list)\n")
615
616
 
616
617
 
617
618
class cmd_mkdir(Command):
2408
2409
                            continue
2409
2410
                    kindch = entry.kind_character()
2410
2411
                    outstring = fp + kindch
 
2412
                    ui.ui_factory.clear_term()
2411
2413
                    if verbose:
2412
2414
                        outstring = '%-8s %s' % (fc, outstring)
2413
2415
                        if show_ids and fid is not None:
4843
4845
        'revision',
4844
4846
        'message',
4845
4847
        Option('body', help='Body for the email.', type=unicode),
4846
 
        RegistryOption.from_kwargs('format',
4847
 
        'Use the specified output format.',
4848
 
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
4849
 
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
4848
        RegistryOption('format',
 
4849
                       help='Use the specified output format.', 
 
4850
                       lazy_registry=('bzrlib.send', 'format_registry'))
4850
4851
        ]
4851
4852
 
4852
4853
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
4853
4854
            no_patch=False, revision=None, remember=False, output=None,
4854
4855
            format=None, mail_to=None, message=None, body=None, **kwargs):
4855
 
        return self._run(submit_branch, revision, public_branch, remember,
 
4856
        from bzrlib.send import send
 
4857
        return send(submit_branch, revision, public_branch, remember,
4856
4858
                         format, no_bundle, no_patch, output,
4857
 
                         kwargs.get('from', '.'), mail_to, message, body)
4858
 
 
4859
 
    def _run(self, submit_branch, revision, public_branch, remember, format,
4860
 
             no_bundle, no_patch, output, from_, mail_to, message, body):
4861
 
        from bzrlib.revision import NULL_REVISION
4862
 
        tree, branch = bzrdir.BzrDir.open_containing_tree_or_branch(from_)[:2]
4863
 
        # we may need to write data into branch's repository to calculate
4864
 
        # the data to send.
4865
 
        branch.lock_write()
4866
 
        try:
4867
 
            if output is None:
4868
 
                config = branch.get_config()
4869
 
                if mail_to is None:
4870
 
                    mail_to = config.get_user_option('submit_to')
4871
 
                mail_client = config.get_mail_client()
4872
 
                if (not getattr(mail_client, 'supports_body', False)
4873
 
                    and body is not None):
4874
 
                    raise errors.BzrCommandError(
4875
 
                        'Mail client "%s" does not support specifying body' %
4876
 
                        mail_client.__class__.__name__)
4877
 
            if remember and submit_branch is None:
4878
 
                raise errors.BzrCommandError(
4879
 
                    '--remember requires a branch to be specified.')
4880
 
            stored_submit_branch = branch.get_submit_branch()
4881
 
            remembered_submit_branch = None
4882
 
            if submit_branch is None:
4883
 
                submit_branch = stored_submit_branch
4884
 
                remembered_submit_branch = "submit"
4885
 
            else:
4886
 
                if stored_submit_branch is None or remember:
4887
 
                    branch.set_submit_branch(submit_branch)
4888
 
            if submit_branch is None:
4889
 
                submit_branch = branch.get_parent()
4890
 
                remembered_submit_branch = "parent"
4891
 
            if submit_branch is None:
4892
 
                raise errors.BzrCommandError('No submit branch known or'
4893
 
                                             ' specified')
4894
 
            if remembered_submit_branch is not None:
4895
 
                note('Using saved %s location "%s" to determine what '
4896
 
                        'changes to submit.', remembered_submit_branch,
4897
 
                        submit_branch)
4898
 
 
4899
 
            if mail_to is None or format is None:
4900
 
                submit_config = Branch.open(submit_branch).get_config()
4901
 
                if mail_to is None:
4902
 
                    mail_to = submit_config.get_user_option("child_submit_to")
4903
 
                if format is None:
4904
 
                    format = submit_config.get_user_option("child_submit_format")
4905
 
 
4906
 
            stored_public_branch = branch.get_public_branch()
4907
 
            if public_branch is None:
4908
 
                public_branch = stored_public_branch
4909
 
            elif stored_public_branch is None or remember:
4910
 
                branch.set_public_branch(public_branch)
4911
 
            if no_bundle and public_branch is None:
4912
 
                raise errors.BzrCommandError('No public branch specified or'
4913
 
                                             ' known')
4914
 
            base_revision_id = None
4915
 
            revision_id = None
4916
 
            if revision is not None:
4917
 
                if len(revision) > 2:
4918
 
                    raise errors.BzrCommandError('bzr send takes '
4919
 
                        'at most two one revision identifiers')
4920
 
                revision_id = revision[-1].as_revision_id(branch)
4921
 
                if len(revision) == 2:
4922
 
                    base_revision_id = revision[0].as_revision_id(branch)
4923
 
            if revision_id is None:
4924
 
                revision_id = branch.last_revision()
4925
 
            if revision_id == NULL_REVISION:
4926
 
                raise errors.BzrCommandError('No revisions to submit.')
4927
 
            if format is None:
4928
 
                format = '4'
4929
 
            if format == '4':
4930
 
                directive = merge_directive.MergeDirective2.from_objects(
4931
 
                    branch.repository, revision_id, time.time(),
4932
 
                    osutils.local_time_offset(), submit_branch,
4933
 
                    public_branch=public_branch, include_patch=not no_patch,
4934
 
                    include_bundle=not no_bundle, message=message,
4935
 
                    base_revision_id=base_revision_id)
4936
 
            elif format == '0.9':
4937
 
                if not no_bundle:
4938
 
                    if not no_patch:
4939
 
                        patch_type = 'bundle'
4940
 
                    else:
4941
 
                        raise errors.BzrCommandError('Format 0.9 does not'
4942
 
                            ' permit bundle with no patch')
4943
 
                else:
4944
 
                    if not no_patch:
4945
 
                        patch_type = 'diff'
4946
 
                    else:
4947
 
                        patch_type = None
4948
 
                directive = merge_directive.MergeDirective.from_objects(
4949
 
                    branch.repository, revision_id, time.time(),
4950
 
                    osutils.local_time_offset(), submit_branch,
4951
 
                    public_branch=public_branch, patch_type=patch_type,
4952
 
                    message=message)
4953
 
            else:
4954
 
                raise errors.BzrCommandError("No such send format '%s'." % 
4955
 
                                             format)
4956
 
 
4957
 
            if output is None:
4958
 
                directive.compose_merge_request(mail_client, mail_to, body,
4959
 
                                                branch, tree)
4960
 
            else:
4961
 
                if output == '-':
4962
 
                    outfile = self.outf
4963
 
                else:
4964
 
                    outfile = open(output, 'wb')
4965
 
                try:
4966
 
                    outfile.writelines(directive.to_lines())
4967
 
                finally:
4968
 
                    if outfile is not self.outf:
4969
 
                        outfile.close()
4970
 
        finally:
4971
 
            branch.unlock()
 
4859
                         kwargs.get('from', '.'), mail_to, message, body,
 
4860
                         self.outf)
4972
4861
 
4973
4862
 
4974
4863
class cmd_bundle_revisions(cmd_send):
4975
 
 
4976
4864
    """Create a merge-directive for submitting changes.
4977
4865
 
4978
4866
    A merge directive provides many things needed for requesting merges:
5020
4908
        Option('output', short_name='o', help='Write directive to this file.',
5021
4909
               type=unicode),
5022
4910
        'revision',
5023
 
        RegistryOption.from_kwargs('format',
5024
 
        'Use the specified output format.',
5025
 
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
5026
 
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
4911
        RegistryOption('format',
 
4912
                       help='Use the specified output format.',
 
4913
                       lazy_registry=('bzrlib.send', 'format_registry')),
5027
4914
        ]
5028
4915
    aliases = ['bundle']
5029
4916
 
5036
4923
            format=None, **kwargs):
5037
4924
        if output is None:
5038
4925
            output = '-'
5039
 
        return self._run(submit_branch, revision, public_branch, remember,
 
4926
        from bzrlib.send import send
 
4927
        return send(submit_branch, revision, public_branch, remember,
5040
4928
                         format, no_bundle, no_patch, output,
5041
 
                         kwargs.get('from', '.'), None, None, None)
 
4929
                         kwargs.get('from', '.'), None, None, None,
 
4930
                         self.outf)
5042
4931
 
5043
4932
 
5044
4933
class cmd_tag(Command):
5139
5028
        if not tags:
5140
5029
            return
5141
5030
 
5142
 
        if revision:
5143
 
            branch.lock_read()
5144
 
            try:
 
5031
        branch.lock_read()
 
5032
        try:
 
5033
            if revision:
5145
5034
                graph = branch.repository.get_graph()
5146
5035
                rev1, rev2 = _get_revision_range(revision, branch, self.name())
5147
5036
                revid1, revid2 = rev1.rev_id, rev2.rev_id
5148
5037
                # only show revisions between revid1 and revid2 (inclusive)
5149
5038
                tags = [(tag, revid) for tag, revid in tags if
5150
5039
                    graph.is_between(revid, revid1, revid2)]
5151
 
            finally:
5152
 
                branch.unlock()
5153
 
        if sort == 'alpha':
5154
 
            tags.sort()
5155
 
        elif sort == 'time':
5156
 
            timestamps = {}
5157
 
            for tag, revid in tags:
5158
 
                try:
5159
 
                    revobj = branch.repository.get_revision(revid)
5160
 
                except errors.NoSuchRevision:
5161
 
                    timestamp = sys.maxint # place them at the end
5162
 
                else:
5163
 
                    timestamp = revobj.timestamp
5164
 
                timestamps[revid] = timestamp
5165
 
            tags.sort(key=lambda x: timestamps[x[1]])
5166
 
        if not show_ids:
5167
 
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5168
 
            revno_map = branch.get_revision_id_to_revno_map()
5169
 
            tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
5170
 
                        for tag, revid in tags ]
 
5040
            if sort == 'alpha':
 
5041
                tags.sort()
 
5042
            elif sort == 'time':
 
5043
                timestamps = {}
 
5044
                for tag, revid in tags:
 
5045
                    try:
 
5046
                        revobj = branch.repository.get_revision(revid)
 
5047
                    except errors.NoSuchRevision:
 
5048
                        timestamp = sys.maxint # place them at the end
 
5049
                    else:
 
5050
                        timestamp = revobj.timestamp
 
5051
                    timestamps[revid] = timestamp
 
5052
                tags.sort(key=lambda x: timestamps[x[1]])
 
5053
            if not show_ids:
 
5054
                # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
 
5055
                for index, (tag, revid) in enumerate(tags):
 
5056
                    try:
 
5057
                        revno = branch.revision_id_to_dotted_revno(revid)
 
5058
                        if isinstance(revno, tuple):
 
5059
                            revno = '.'.join(map(str, revno))
 
5060
                    except errors.NoSuchRevision:
 
5061
                        # Bad tag data/merges can lead to tagged revisions
 
5062
                        # which are not in this branch. Fail gracefully ...
 
5063
                        revno = '?'
 
5064
                    tags[index] = (tag, revno)
 
5065
        finally:
 
5066
            branch.unlock()
5171
5067
        for tag, revspec in tags:
5172
5068
            self.outf.write('%-20s %s\n' % (tag, revspec))
5173
5069