/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: Martin
  • Date: 2017-06-18 10:15:11 UTC
  • mto: This revision was merged to the branch mainline in revision 6715.
  • Revision ID: gzlist@googlemail.com-20170618101511-fri1mouxt1hc09r8
Make _simple_set tests pass on py3 and with random hash

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('\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
    f = open(ignore_path, 'wb')
 
132
    try:
 
133
        for pattern in patterns:
 
134
            f.write(pattern.encode('utf8') + '\n')
 
135
    finally:
 
136
        f.close()
 
137
 
 
138
 
 
139
def add_unique_user_ignores(new_ignores):
 
140
    """Add entries to the user's ignore list if not present.
 
141
 
 
142
    :param new_ignores: A list of ignore patterns
 
143
    :return: The list of ignores that were added
 
144
    """
 
145
    ignored = get_user_ignores()
 
146
    to_add = []
 
147
    for ignore in new_ignores:
 
148
        ignore = globbing.normalize_pattern(ignore)
 
149
        if ignore not in ignored:
 
150
            ignored.add(ignore)
 
151
            to_add.append(ignore)
 
152
 
 
153
    if not to_add:
 
154
        return []
 
155
 
 
156
    f = open(config.user_ignore_config_filename(), 'ab')
 
157
    try:
 
158
        for pattern in to_add:
 
159
            f.write(pattern.encode('utf8') + '\n')
 
160
    finally:
 
161
        f.close()
 
162
 
 
163
    return to_add
 
164
 
 
165
 
 
166
_runtime_ignores = set()
 
167
 
 
168
 
 
169
def add_runtime_ignores(ignores):
 
170
    """Add some ignore patterns that only exists in memory.
 
171
 
 
172
    This is used by some plugins that want bzr to ignore files,
 
173
    but don't want to change a users ignore list.
 
174
    (Such as a conversion script that needs to ignore temporary files,
 
175
    but does not want to modify the project's ignore list.)
 
176
 
 
177
    :param ignores: A list or generator of ignore patterns.
 
178
    :return: None
 
179
    """
 
180
    global _runtime_ignores
 
181
    _runtime_ignores.update(set(ignores))
 
182
 
 
183
 
 
184
def get_runtime_ignores():
 
185
    """Get the current set of runtime ignores."""
 
186
    return _runtime_ignores
 
187
 
 
188
 
 
189
def tree_ignores_add_patterns(tree, name_pattern_list):
 
190
    """Add more ignore patterns to the ignore file in a tree.
 
191
    If ignore file does not exist then it will be created.
 
192
    The ignore file will be automatically added under version control.
 
193
 
 
194
    :param tree: Working tree to update the ignore list.
 
195
    :param name_pattern_list: List of ignore patterns.
 
196
    :return: None
 
197
    """
 
198
    # read in the existing ignores set
 
199
    ifn = tree.abspath(breezy.IGNORE_FILENAME)
 
200
    if tree.has_filename(ifn):
 
201
        f = open(ifn, 'rU')
 
202
        try:
 
203
            file_contents = f.read()
 
204
            # figure out what kind of line endings are used
 
205
            newline = getattr(f, 'newlines', None)
 
206
            if isinstance(newline, tuple):
 
207
                newline = newline[0]
 
208
            elif newline is None:
 
209
                newline = os.linesep
 
210
        finally:
 
211
            f.close()
 
212
    else:
 
213
        file_contents = ""
 
214
        newline = os.linesep
 
215
    
 
216
    sio = BytesIO(file_contents)
 
217
    try:
 
218
        ignores = parse_ignore_file(sio)
 
219
    finally:
 
220
        sio.close()
 
221
    
 
222
    # write out the updated ignores set
 
223
    f = atomicfile.AtomicFile(ifn, 'wb')
 
224
    try:
 
225
        # write the original contents, preserving original line endings
 
226
        f.write(newline.join(file_contents.split('\n')))
 
227
        if len(file_contents) > 0 and not file_contents.endswith('\n'):
 
228
            f.write(newline)
 
229
        for pattern in name_pattern_list:
 
230
            if not pattern in ignores:
 
231
                f.write(pattern.encode('utf-8'))
 
232
                f.write(newline)
 
233
        f.commit()
 
234
    finally:
 
235
        f.close()
 
236
 
 
237
    if not tree.path2id(breezy.IGNORE_FILENAME):
 
238
        tree.add([breezy.IGNORE_FILENAME])