/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-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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