/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-05-19 13:16:11 UTC
  • mto: (6968.4.3 git-archive)
  • mto: This revision was merged to the branch mainline in revision 6972.
  • Revision ID: jelmer@jelmer.uk-20180519131611-l9h9ud41j7qg1m03
Move tar/zip to breezy.archive.

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
import os
 
23
 
 
24
import breezy
 
25
from .lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
from breezy import (
 
28
    atomicfile,
 
29
    config,
 
30
    globbing,
 
31
    trace,
 
32
    )
 
33
""")
 
34
from breezy.sixish import (
 
35
    BytesIO,
 
36
    )
 
37
 
 
38
# ~/.bazaar/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
 
 
56
def parse_ignore_file(f):
 
57
    """Read in all of the lines in the file and turn it into an ignore list
 
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 
 
61
    errors.
 
62
    """
 
63
    ignored = set()
 
64
    ignore_file = f.read()
 
65
    try:
 
66
        # Try and parse whole ignore file at once.
 
67
        unicode_lines = ignore_file.decode('utf8').split('\n')
 
68
    except UnicodeDecodeError:
 
69
        # Otherwise go though line by line and pick out the 'good'
 
70
        # decodable lines
 
71
        lines = ignore_file.split(b'\n')
 
72
        unicode_lines = []
 
73
        for line_number, line in enumerate(lines):
 
74
            try:
 
75
                unicode_lines.append(line.decode('utf-8'))
 
76
            except UnicodeDecodeError:
 
77
                # report error about line (idx+1)
 
78
                trace.warning(
 
79
                        '.bzrignore: On Line #%d, malformed utf8 character. '
 
80
                        'Ignoring line.' % (line_number+1))
 
81
 
 
82
    # Append each line to ignore list if it's not a comment line
 
83
    for line in unicode_lines:
 
84
        line = line.rstrip('\r\n')
 
85
        if not line or line.startswith('#'):
 
86
            continue
 
87
        ignored.add(globbing.normalize_pattern(line))
 
88
    return ignored
 
89
 
 
90
 
 
91
def get_user_ignores():
 
92
    """Get the list of user ignored files, possibly creating it."""
 
93
    path = config.user_ignore_config_filename()
 
94
    patterns = set(USER_DEFAULTS)
 
95
    try:
 
96
        f = open(path, 'rb')
 
97
    except (IOError, OSError) as e:
 
98
        # open() shouldn't return an IOError without errno, but just in case
 
99
        err = getattr(e, 'errno', None)
 
100
        if err not in (errno.ENOENT,):
 
101
            raise
 
102
        # Create the ignore file, and just return the default
 
103
        # We want to ignore if we can't write to the file
 
104
        # since get_* should be a safe operation
 
105
        try:
 
106
            _set_user_ignores(USER_DEFAULTS)
 
107
        except (IOError, OSError) as e:
 
108
            if e.errno not in (errno.EPERM,):
 
109
                raise
 
110
        return patterns
 
111
 
 
112
    try:
 
113
        return parse_ignore_file(f)
 
114
    finally:
 
115
        f.close()
 
116
 
 
117
 
 
118
def _set_user_ignores(patterns):
 
119
    """Fill out the user ignore file with the given patterns
 
120
 
 
121
    This may raise an error if it doesn't have permission to
 
122
    write to the user ignore file.
 
123
    This is mostly used for testing, since it would be
 
124
    bad form to rewrite a user's ignore list.
 
125
    breezy only writes this file if it does not exist.
 
126
    """
 
127
    ignore_path = config.user_ignore_config_filename()
 
128
    config.ensure_config_dir_exists()
 
129
 
 
130
    # Create an empty file
 
131
    with open(ignore_path, 'wb') as f:
 
132
        for pattern in patterns:
 
133
            f.write(pattern.encode('utf8') + b'\n')
 
134
 
 
135
 
 
136
def add_unique_user_ignores(new_ignores):
 
137
    """Add entries to the user's ignore list if not present.
 
138
 
 
139
    :param new_ignores: A list of ignore patterns
 
140
    :return: The list of ignores that were added
 
141
    """
 
142
    ignored = get_user_ignores()
 
143
    to_add = []
 
144
    for ignore in new_ignores:
 
145
        ignore = globbing.normalize_pattern(ignore)
 
146
        if ignore not in ignored:
 
147
            ignored.add(ignore)
 
148
            to_add.append(ignore)
 
149
 
 
150
    if not to_add:
 
151
        return []
 
152
 
 
153
    with open(config.user_ignore_config_filename(), 'ab') as f:
 
154
        for pattern in to_add:
 
155
            f.write(pattern.encode('utf8') + b'\n')
 
156
 
 
157
    return to_add
 
158
 
 
159
 
 
160
_runtime_ignores = set()
 
161
 
 
162
 
 
163
def add_runtime_ignores(ignores):
 
164
    """Add some ignore patterns that only exists in memory.
 
165
 
 
166
    This is used by some plugins that want bzr to ignore files,
 
167
    but don't want to change a users ignore list.
 
168
    (Such as a conversion script that needs to ignore temporary files,
 
169
    but does not want to modify the project's ignore list.)
 
170
 
 
171
    :param ignores: A list or generator of ignore patterns.
 
172
    :return: None
 
173
    """
 
174
    global _runtime_ignores
 
175
    _runtime_ignores.update(set(ignores))
 
176
 
 
177
 
 
178
def get_runtime_ignores():
 
179
    """Get the current set of runtime ignores."""
 
180
    return _runtime_ignores
 
181
 
 
182
 
 
183
def tree_ignores_add_patterns(tree, name_pattern_list):
 
184
    """Add more ignore patterns to the ignore file in a tree.
 
185
    If ignore file does not exist then it will be created.
 
186
    The ignore file will be automatically added under version control.
 
187
 
 
188
    :param tree: Working tree to update the ignore list.
 
189
    :param name_pattern_list: List of ignore patterns.
 
190
    :return: None
 
191
    """
 
192
    # read in the existing ignores set
 
193
    ifn = tree.abspath(tree._format.ignore_filename)
 
194
    if tree.has_filename(ifn):
 
195
        with open(ifn, 'rbU') as f:
 
196
            file_contents = f.read()
 
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()
 
203
    else:
 
204
        file_contents = b""
 
205
        newline = os.linesep.encode()
 
206
 
 
207
    sio = BytesIO(file_contents)
 
208
    try:
 
209
        ignores = parse_ignore_file(sio)
 
210
    finally:
 
211
        sio.close()
 
212
 
 
213
    # write out the updated ignores set
 
214
    f = atomicfile.AtomicFile(ifn, 'wb')
 
215
    try:
 
216
        # write the original contents, preserving original line endings
 
217
        f.write(newline.join(file_contents.split(b'\n')))
 
218
        if len(file_contents) > 0 and not file_contents.endswith(b'\n'):
 
219
            f.write(newline)
 
220
        for pattern in name_pattern_list:
 
221
            if not pattern in ignores:
 
222
                f.write(pattern.encode('utf-8'))
 
223
                f.write(newline)
 
224
        f.commit()
 
225
    finally:
 
226
        f.close()
 
227
 
 
228
    if not tree.is_versioned(tree._format.ignore_filename):
 
229
        tree.add([tree._format.ignore_filename])