/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/ignores.py

  • Committer: Jelmer Vernooij
  • Date: 2018-08-26 02:01:46 UTC
  • mto: This revision was merged to the branch mainline in revision 7087.
  • Revision ID: jelmer@jelmer.uk-20180826020146-owq7fxsr6ermorlh
Fix remaining warnings on Python 3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/ignores.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-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
16
16
 
17
17
"""Lists of ignore files, etc."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import errno
 
22
import os
20
23
 
21
 
import bzrlib
22
 
from bzrlib import (
 
24
import breezy
 
25
from .lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
from breezy import (
23
28
    atomicfile,
24
29
    config,
25
30
    globbing,
26
 
    )
27
 
 
28
 
from trace import warning
 
31
    trace,
 
32
    )
 
33
""")
 
34
from breezy.sixish import (
 
35
    BytesIO,
 
36
    )
29
37
 
30
38
# ~/.bazaar/ignore will be filled out using
31
39
# this ignore list, if it does not exist
39
47
    '*~',
40
48
    '.#*',
41
49
    '[#]*#',
 
50
    '__pycache__',
 
51
    'bzr-orphans',
42
52
]
43
53
 
44
54
 
58
68
    except UnicodeDecodeError:
59
69
        # Otherwise go though line by line and pick out the 'good'
60
70
        # decodable lines
61
 
        lines = ignore_file.split('\n')
 
71
        lines = ignore_file.split(b'\n')
62
72
        unicode_lines = []
63
73
        for line_number, line in enumerate(lines):
64
74
            try:
65
75
                unicode_lines.append(line.decode('utf-8'))
66
76
            except UnicodeDecodeError:
67
77
                # report error about line (idx+1)
68
 
                warning('.bzrignore: On Line #%d, malformed utf8 character. '
 
78
                trace.warning(
 
79
                        '.bzrignore: On Line #%d, malformed utf8 character. '
69
80
                        'Ignoring line.' % (line_number+1))
70
81
 
71
82
    # Append each line to ignore list if it's not a comment line
83
94
    patterns = set(USER_DEFAULTS)
84
95
    try:
85
96
        f = open(path, 'rb')
86
 
    except (IOError, OSError), e:
 
97
    except (IOError, OSError) as e:
87
98
        # open() shouldn't return an IOError without errno, but just in case
88
99
        err = getattr(e, 'errno', None)
89
100
        if err not in (errno.ENOENT,):
93
104
        # since get_* should be a safe operation
94
105
        try:
95
106
            _set_user_ignores(USER_DEFAULTS)
96
 
        except (IOError, OSError), e:
 
107
        except (IOError, OSError) as e:
97
108
            if e.errno not in (errno.EPERM,):
98
109
                raise
99
110
        return patterns
111
122
    write to the user ignore file.
112
123
    This is mostly used for testing, since it would be
113
124
    bad form to rewrite a user's ignore list.
114
 
    bzrlib only writes this file if it does not exist.
 
125
    breezy only writes this file if it does not exist.
115
126
    """
116
127
    ignore_path = config.user_ignore_config_filename()
117
128
    config.ensure_config_dir_exists()
118
129
 
119
130
    # Create an empty file
120
 
    f = open(ignore_path, 'wb')
121
 
    try:
 
131
    with open(ignore_path, 'wb') as f:
122
132
        for pattern in patterns:
123
 
            f.write(pattern.encode('utf8') + '\n')
124
 
    finally:
125
 
        f.close()
 
133
            f.write(pattern.encode('utf8') + b'\n')
126
134
 
127
135
 
128
136
def add_unique_user_ignores(new_ignores):
142
150
    if not to_add:
143
151
        return []
144
152
 
145
 
    f = open(config.user_ignore_config_filename(), 'ab')
146
 
    try:
 
153
    with open(config.user_ignore_config_filename(), 'ab') as f:
147
154
        for pattern in to_add:
148
 
            f.write(pattern.encode('utf8') + '\n')
149
 
    finally:
150
 
        f.close()
 
155
            f.write(pattern.encode('utf8') + b'\n')
151
156
 
152
157
    return to_add
153
158
 
181
186
    The ignore file will be automatically added under version control.
182
187
 
183
188
    :param tree: Working tree to update the ignore list.
 
189
    :param name_pattern_list: List of ignore patterns.
 
190
    :return: None
184
191
    """
185
 
    ifn = tree.abspath(bzrlib.IGNORE_FILENAME)
 
192
    # read in the existing ignores set
 
193
    ifn = tree.abspath(tree._format.ignore_filename)
186
194
    if tree.has_filename(ifn):
187
 
        f = open(ifn, 'rt')
188
 
        try:
189
 
            igns = f.read().decode('utf-8')
190
 
        finally:
191
 
            f.close()
 
195
        with open(ifn, 'rbU') as f:
 
196
            file_contents = f.read()
 
197
            # figure out what kind of line endings are used
 
198
            newline = getattr(f, 'newlines', None)
 
199
            if isinstance(newline, tuple):
 
200
                newline = newline[0]
 
201
            elif newline is None:
 
202
                newline = os.linesep.encode()
192
203
    else:
193
 
        igns = ""
194
 
 
195
 
    # TODO: If the file already uses crlf-style termination, maybe
196
 
    # we should use that for the newly added lines?
197
 
 
198
 
    if igns and igns[-1] != '\n':
199
 
        igns += '\n'
200
 
    for name_pattern in name_pattern_list:
201
 
        igns += name_pattern + '\n'
202
 
 
 
204
        file_contents = b""
 
205
        newline = os.linesep.encode()
 
206
 
 
207
    sio = BytesIO(file_contents)
 
208
    try:
 
209
        ignores = parse_ignore_file(sio)
 
210
    finally:
 
211
        sio.close()
 
212
 
 
213
    # write out the updated ignores set
203
214
    f = atomicfile.AtomicFile(ifn, 'wb')
204
215
    try:
205
 
        f.write(igns.encode('utf-8'))
 
216
        # write the original contents, preserving original line endings
 
217
        f.write(newline.join(file_contents.split(b'\n')))
 
218
        if len(file_contents) > 0 and not file_contents.endswith(b'\n'):
 
219
            f.write(newline)
 
220
        for pattern in name_pattern_list:
 
221
            if not pattern in ignores:
 
222
                f.write(pattern.encode('utf-8'))
 
223
                f.write(newline)
206
224
        f.commit()
207
225
    finally:
208
226
        f.close()
209
227
 
210
 
    if not tree.path2id(bzrlib.IGNORE_FILENAME):
211
 
        tree.add([bzrlib.IGNORE_FILENAME])
 
228
    if not tree.is_versioned(tree._format.ignore_filename):
 
229
        tree.add([tree._format.ignore_filename])