/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-18 22:45:58 UTC
  • mto: This revision was merged to the branch mainline in revision 7101.
  • Revision ID: jelmer@jelmer.uk-20180818224558-8ki0baw0ea5jmlqa
Some more walkdir fixes.

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