/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-02-07 02:14:30 UTC
  • mto: This revision was merged to the branch mainline in revision 7492.
  • Revision ID: jelmer@jelmer.uk-20200207021430-m49iq3x4x8xlib6x
Drop python2 support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/ignores.py
 
1
# Copyright (C) 2006-2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Lists of ignore files, etc."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
import errno
 
22
from io import BytesIO
 
23
import os
 
24
 
 
25
import breezy
 
26
from .lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
from breezy import (
 
29
    atomicfile,
 
30
    globbing,
 
31
    trace,
 
32
    )
 
33
""")
 
34
from . import (
 
35
    bedding,
 
36
    )
 
37
 
 
38
# ~/.config/breezy/ignore will be filled out using
 
39
# this ignore list, if it does not exist
 
40
# please keep these sorted (in C locale order) to aid merging
 
41
USER_DEFAULTS = [
 
42
    '*.a',
 
43
    '*.o',
 
44
    '*.py[co]',
 
45
    '*.so',
 
46
    '*.sw[nop]',
 
47
    '*~',
 
48
    '.#*',
 
49
    '[#]*#',
 
50
    '__pycache__',
 
51
    'bzr-orphans',
 
52
]
 
53
 
 
54
 
 
55
def parse_ignore_file(f):
 
56
    """Read in all of the lines in the file and turn it into an ignore list
 
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
 
60
    errors.
 
61
    """
 
62
    ignored = set()
 
63
    ignore_file = f.read()
 
64
    try:
 
65
        # Try and parse whole ignore file at once.
 
66
        unicode_lines = ignore_file.decode('utf8').split('\n')
 
67
    except UnicodeDecodeError:
 
68
        # Otherwise go though line by line and pick out the 'good'
 
69
        # decodable lines
 
70
        lines = ignore_file.split(b'\n')
 
71
        unicode_lines = []
 
72
        for line_number, line in enumerate(lines):
 
73
            try:
 
74
                unicode_lines.append(line.decode('utf-8'))
 
75
            except UnicodeDecodeError:
 
76
                # report error about line (idx+1)
 
77
                trace.warning(
 
78
                    '.bzrignore: On Line #%d, malformed utf8 character. '
 
79
                    'Ignoring line.' % (line_number + 1))
 
80
 
 
81
    # Append each line to ignore list if it's not a comment line
 
82
    for line in unicode_lines:
 
83
        line = line.rstrip('\r\n')
 
84
        if not line or line.startswith('#'):
 
85
            continue
 
86
        ignored.add(globbing.normalize_pattern(line))
 
87
    return ignored
 
88
 
 
89
 
 
90
def get_user_ignores():
 
91
    """Get the list of user ignored files, possibly creating it."""
 
92
    path = bedding.user_ignore_config_path()
 
93
    patterns = set(USER_DEFAULTS)
 
94
    try:
 
95
        f = open(path, 'rb')
 
96
    except (IOError, OSError) as e:
 
97
        # open() shouldn't return an IOError without errno, but just in case
 
98
        err = getattr(e, 'errno', None)
 
99
        if err not in (errno.ENOENT,):
 
100
            raise
 
101
        # Create the ignore file, and just return the default
 
102
        # We want to ignore if we can't write to the file
 
103
        # since get_* should be a safe operation
 
104
        try:
 
105
            _set_user_ignores(USER_DEFAULTS)
 
106
        except EnvironmentError as e:
 
107
            if e.errno not in (errno.EPERM, errno.ENOENT):
 
108
                raise
 
109
        return patterns
 
110
 
 
111
    try:
 
112
        return parse_ignore_file(f)
 
113
    finally:
 
114
        f.close()
 
115
 
 
116
 
 
117
def _set_user_ignores(patterns):
 
118
    """Fill out the user ignore file with the given patterns
 
119
 
 
120
    This may raise an error if it doesn't have permission to
 
121
    write to the user ignore file.
 
122
    This is mostly used for testing, since it would be
 
123
    bad form to rewrite a user's ignore list.
 
124
    breezy only writes this file if it does not exist.
 
125
    """
 
126
    ignore_path = bedding.user_ignore_config_path()
 
127
    bedding.ensure_config_dir_exists()
 
128
 
 
129
    # Create an empty file
 
130
    with open(ignore_path, 'wb') as f:
 
131
        for pattern in patterns:
 
132
            f.write(pattern.encode('utf8') + b'\n')
 
133
 
 
134
 
 
135
def add_unique_user_ignores(new_ignores):
 
136
    """Add entries to the user's ignore list if not present.
 
137
 
 
138
    :param new_ignores: A list of ignore patterns
 
139
    :return: The list of ignores that were added
 
140
    """
 
141
    ignored = get_user_ignores()
 
142
    to_add = []
 
143
    for ignore in new_ignores:
 
144
        ignore = globbing.normalize_pattern(ignore)
 
145
        if ignore not in ignored:
 
146
            ignored.add(ignore)
 
147
            to_add.append(ignore)
 
148
 
 
149
    if not to_add:
 
150
        return []
 
151
 
 
152
    with open(bedding.user_ignore_config_path(), 'ab') as f:
 
153
        for pattern in to_add:
 
154
            f.write(pattern.encode('utf8') + b'\n')
 
155
 
 
156
    return to_add
 
157
 
 
158
 
 
159
_runtime_ignores = set()
 
160
 
 
161
 
 
162
def add_runtime_ignores(ignores):
 
163
    """Add some ignore patterns that only exists in memory.
 
164
 
 
165
    This is used by some plugins that want bzr to ignore files,
 
166
    but don't want to change a users ignore list.
 
167
    (Such as a conversion script that needs to ignore temporary files,
 
168
    but does not want to modify the project's ignore list.)
 
169
 
 
170
    :param ignores: A list or generator of ignore patterns.
 
171
    :return: None
 
172
    """
 
173
    global _runtime_ignores
 
174
    _runtime_ignores.update(set(ignores))
 
175
 
 
176
 
 
177
def get_runtime_ignores():
 
178
    """Get the current set of runtime ignores."""
 
179
    return _runtime_ignores
 
180
 
 
181
 
 
182
def tree_ignores_add_patterns(tree, name_pattern_list):
 
183
    """Add more ignore patterns to the ignore file in a tree.
 
184
    If ignore file does not exist then it will be created.
 
185
    The ignore file will be automatically added under version control.
 
186
 
 
187
    :param tree: Working tree to update the ignore list.
 
188
    :param name_pattern_list: List of ignore patterns.
 
189
    :return: None
 
190
    """
 
191
    # read in the existing ignores set
 
192
    ifn = tree.abspath(tree._format.ignore_filename)
 
193
    if tree.has_filename(ifn):
 
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'
 
200
    else:
 
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])