/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 breezy/revision.py

  • Committer: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/revision.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
18
18
# perhaps show them in log -v and allow them as options to the commit command.
19
19
 
20
20
 
21
 
from bzrlib.lazy_import import lazy_import
 
21
from .lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
 
from bzrlib import deprecated_graph
24
 
from bzrlib import bugtracker
 
23
from breezy import bugtracker
25
24
""")
26
 
from bzrlib import (
 
25
from . import (
27
26
    errors,
28
 
    symbol_versioning,
 
27
    osutils,
29
28
    )
30
 
from bzrlib.osutils import contains_whitespace
31
29
 
32
 
NULL_REVISION="null:"
33
 
CURRENT_REVISION="current:"
 
30
NULL_REVISION = b"null:"
 
31
CURRENT_REVISION = b"current:"
34
32
 
35
33
 
36
34
class Revision(object):
71
69
        if not isinstance(other, Revision):
72
70
            return False
73
71
        return (
74
 
                self.inventory_sha1 == other.inventory_sha1
75
 
                and self.revision_id == other.revision_id
76
 
                and self.timestamp == other.timestamp
77
 
                and self.message == other.message
78
 
                and self.timezone == other.timezone
79
 
                and self.committer == other.committer
80
 
                and self.properties == other.properties
81
 
                and self.parent_ids == other.parent_ids)
 
72
            self.inventory_sha1 == other.inventory_sha1
 
73
            and self.revision_id == other.revision_id
 
74
            and self.timestamp == other.timestamp
 
75
            and self.message == other.message
 
76
            and self.timezone == other.timezone
 
77
            and self.committer == other.committer
 
78
            and self.properties == other.properties
 
79
            and self.parent_ids == other.parent_ids)
82
80
 
83
81
    def __ne__(self, other):
84
82
        return not self.__eq__(other)
85
83
 
86
84
    def _check_properties(self):
87
85
        """Verify that all revision properties are OK."""
88
 
        for name, value in self.properties.iteritems():
89
 
            if not isinstance(name, basestring) or contains_whitespace(name):
 
86
        for name, value in self.properties.items():
 
87
            # GZ 2017-06-10: What sort of string are properties exactly?
 
88
            not_text = not isinstance(name, str)
 
89
            if not_text or osutils.contains_whitespace(name):
90
90
                raise ValueError("invalid property name %r" % name)
91
 
            if not isinstance(value, basestring):
 
91
            if not isinstance(value, (str, bytes)):
92
92
                raise ValueError("invalid property value %r for %r" %
93
93
                                 (value, name))
94
94
 
102
102
        reversed_result = []
103
103
        while current_revision is not None:
104
104
            reversed_result.append(current_revision.revision_id)
105
 
            if not len (current_revision.parent_ids):
 
105
            if not len(current_revision.parent_ids):
106
106
                reversed_result.append(None)
107
107
                current_revision = None
108
108
            else:
121
121
        else:
122
122
            return ''
123
123
 
124
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((1, 13, 0)))
125
 
    def get_apparent_author(self):
126
 
        """Return the apparent author of this revision.
127
 
 
128
 
        This method is deprecated in favour of get_apparent_authors.
129
 
 
130
 
        If the revision properties contain any author names,
131
 
        return the first. Otherwise return the committer name.
132
 
        """
133
 
        authors = self.get_apparent_authors()
134
 
        if authors:
135
 
            return authors[0]
136
 
        else:
137
 
            return None
138
 
 
139
124
    def get_apparent_authors(self):
140
125
        """Return the apparent authors of this revision.
141
126
 
157
142
        """Iterate over the bugs associated with this revision."""
158
143
        bug_property = self.properties.get('bugs', None)
159
144
        if bug_property is None:
160
 
            return
161
 
        for line in bug_property.splitlines():
162
 
            try:
163
 
                url, status = line.split(None, 2)
164
 
            except ValueError:
165
 
                raise errors.InvalidLineInBugsProperty(line)
166
 
            if status not in bugtracker.ALLOWED_BUG_STATUSES:
167
 
                raise errors.InvalidBugStatus(status)
168
 
            yield url, status
 
145
            return iter([])
 
146
        return bugtracker.decode_bug_urls(bug_property)
169
147
 
170
148
 
171
149
def iter_ancestors(revision_id, revision_source, only_present=False):
178
156
                yield ancestor, distance
179
157
            try:
180
158
                revision = revision_source.get_revision(ancestor)
181
 
            except errors.NoSuchRevision, e:
 
159
            except errors.NoSuchRevision as e:
182
160
                if e.revision == revision_id:
183
161
                    raise
184
162
                else:
199
177
    """
200
178
    found_ancestors = {}
201
179
    anc_iter = enumerate(iter_ancestors(revision_id, revision_source,
202
 
                         only_present=True))
 
180
                                        only_present=True))
203
181
    for anc_order, (anc_id, anc_distance) in anc_iter:
204
182
        if anc_id not in found_ancestors:
205
183
            found_ancestors[anc_id] = (anc_order, anc_distance)
220
198
 
221
199
    :return: True if the revision is reserved, False otherwise
222
200
    """
223
 
    return isinstance(revision_id, basestring) and revision_id.endswith(':')
 
201
    return isinstance(revision_id, bytes) and revision_id.endswith(b':')
224
202
 
225
203
 
226
204
def check_not_reserved_id(revision_id):
232
210
def ensure_null(revision_id):
233
211
    """Ensure only NULL_REVISION is used to represent the null revision"""
234
212
    if revision_id is None:
235
 
        symbol_versioning.warn('NULL_REVISION should be used for the null'
236
 
            ' revision instead of None, as of bzr 0.91.',
237
 
            DeprecationWarning, stacklevel=2)
238
 
        return NULL_REVISION
239
 
    else:
240
 
        return revision_id
 
213
        raise ValueError(
 
214
            'NULL_REVISION should be used for the null'
 
215
            ' revision instead of None.')
 
216
    return revision_id
241
217
 
242
218
 
243
219
def is_null(revision_id):
244
220
    if revision_id is None:
245
 
        symbol_versioning.warn('NULL_REVISION should be used for the null'
246
 
            ' revision instead of None, as of bzr 0.90.',
247
 
            DeprecationWarning, stacklevel=2)
248
 
    return revision_id in (None, NULL_REVISION)
 
221
        raise ValueError('NULL_REVISION should be used for the null'
 
222
                         ' revision instead of None.')
 
223
    return (revision_id == NULL_REVISION)