/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: 2020-03-22 21:29:51 UTC
  • mto: (7490.7.7 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200322212951-6nu7tdaq5cff3qg4
Fix git tests.

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