/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-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/ignores.py
16
16
 
17
17
"""Lists of ignore files, etc."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import errno
20
 
from io import BytesIO
21
22
import os
22
23
 
23
24
import breezy
25
26
lazy_import(globals(), """
26
27
from breezy import (
27
28
    atomicfile,
 
29
    config,
28
30
    globbing,
29
31
    trace,
30
32
    )
31
33
""")
32
 
from . import (
33
 
    bedding,
 
34
from breezy.sixish import (
 
35
    BytesIO,
34
36
    )
35
37
 
36
 
# ~/.config/breezy/ignore will be filled out using
 
38
# ~/.bazaar/ignore will be filled out using
37
39
# this ignore list, if it does not exist
38
40
# please keep these sorted (in C locale order) to aid merging
39
41
USER_DEFAULTS = [
50
52
]
51
53
 
52
54
 
 
55
 
53
56
def parse_ignore_file(f):
54
57
    """Read in all of the lines in the file and turn it into an ignore list
55
 
 
56
 
    Continue in the case of utf8 decoding errors, and emit a warning when
57
 
    such and error is found. Optimise for the common case -- no decoding
 
58
    
 
59
    Continue in the case of utf8 decoding errors, and emit a warning when 
 
60
    such and error is found. Optimise for the common case -- no decoding 
58
61
    errors.
59
62
    """
60
63
    ignored = set()
73
76
            except UnicodeDecodeError:
74
77
                # report error about line (idx+1)
75
78
                trace.warning(
76
 
                    '.bzrignore: On Line #%d, malformed utf8 character. '
77
 
                    'Ignoring line.' % (line_number + 1))
 
79
                        '.bzrignore: On Line #%d, malformed utf8 character. '
 
80
                        'Ignoring line.' % (line_number+1))
78
81
 
79
82
    # Append each line to ignore list if it's not a comment line
80
83
    for line in unicode_lines:
87
90
 
88
91
def get_user_ignores():
89
92
    """Get the list of user ignored files, possibly creating it."""
90
 
    path = bedding.user_ignore_config_path()
 
93
    path = config.user_ignore_config_filename()
91
94
    patterns = set(USER_DEFAULTS)
92
95
    try:
93
96
        f = open(path, 'rb')
101
104
        # since get_* should be a safe operation
102
105
        try:
103
106
            _set_user_ignores(USER_DEFAULTS)
104
 
        except EnvironmentError as e:
105
 
            if e.errno not in (errno.EPERM, errno.ENOENT):
 
107
        except (IOError, OSError) as e:
 
108
            if e.errno not in (errno.EPERM,):
106
109
                raise
107
110
        return patterns
108
111
 
121
124
    bad form to rewrite a user's ignore list.
122
125
    breezy only writes this file if it does not exist.
123
126
    """
124
 
    ignore_path = bedding.user_ignore_config_path()
125
 
    bedding.ensure_config_dir_exists()
 
127
    ignore_path = config.user_ignore_config_filename()
 
128
    config.ensure_config_dir_exists()
126
129
 
127
130
    # Create an empty file
128
131
    with open(ignore_path, 'wb') as f:
147
150
    if not to_add:
148
151
        return []
149
152
 
150
 
    with open(bedding.user_ignore_config_path(), 'ab') as f:
 
153
    with open(config.user_ignore_config_filename(), 'ab') as f:
151
154
        for pattern in to_add:
152
155
            f.write(pattern.encode('utf8') + b'\n')
153
156
 
187
190
    :return: None
188
191
    """
189
192
    # read in the existing ignores set
190
 
    ifn = tree.abspath(tree._format.ignore_filename)
 
193
    ifn = tree.abspath(breezy.IGNORE_FILENAME)
191
194
    if tree.has_filename(ifn):
192
 
        with open(ifn, 'rb') as f:
 
195
        with open(ifn, 'rbU') as f:
193
196
            file_contents = f.read()
194
 
            if file_contents.find(b'\r\n') != -1:
195
 
                newline = b'\r\n'
196
 
            else:
197
 
                newline = b'\n'
 
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()
198
203
    else:
199
204
        file_contents = b""
200
205
        newline = os.linesep.encode()
201
 
 
202
 
    with BytesIO(file_contents) as sio:
 
206
    
 
207
    sio = BytesIO(file_contents)
 
208
    try:
203
209
        ignores = parse_ignore_file(sio)
204
 
 
 
210
    finally:
 
211
        sio.close()
 
212
    
205
213
    # write out the updated ignores set
206
 
    with atomicfile.AtomicFile(ifn, 'wb') as f:
 
214
    f = atomicfile.AtomicFile(ifn, 'wb')
 
215
    try:
207
216
        # write the original contents, preserving original line endings
208
 
        f.write(file_contents)
 
217
        f.write(newline.join(file_contents.split(b'\n')))
209
218
        if len(file_contents) > 0 and not file_contents.endswith(b'\n'):
210
219
            f.write(newline)
211
220
        for pattern in name_pattern_list:
212
 
            if pattern not in ignores:
 
221
            if not pattern in ignores:
213
222
                f.write(pattern.encode('utf-8'))
214
223
                f.write(newline)
 
224
        f.commit()
 
225
    finally:
 
226
        f.close()
215
227
 
216
 
    if not tree.is_versioned(tree._format.ignore_filename):
217
 
        tree.add([tree._format.ignore_filename])
 
228
    if not tree.is_versioned(breezy.IGNORE_FILENAME):
 
229
        tree.add([breezy.IGNORE_FILENAME])