← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/ignores.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-11-09 18:19:47 UTC
  • mfrom: (5524.2.1 noshfolder)
  • Revision ID: pqm@pqm.ubuntu.com-20101109181947-h26505clmkdhh2uz
(GaryvdM) Exclude SHFOLDER.dll from py2exe builds,
        as it breaks subvertpy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ignores.py
 
1
# Copyright (C) 2006-2010 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
import errno
 
20
import os
 
21
from cStringIO import StringIO
 
22
 
 
23
import bzrlib
 
24
from bzrlib import (
 
25
    atomicfile,
 
26
    config,
 
27
    globbing,
 
28
    )
 
29
 
 
30
from trace import warning
 
31
 
 
32
# ~/.bazaar/ignore will be filled out using
 
33
# this ignore list, if it does not exist
 
34
# please keep these sorted (in C locale order) to aid merging
 
35
USER_DEFAULTS = [
 
36
    '*.a',
 
37
    '*.o',
 
38
    '*.py[co]',
 
39
    '*.so',
 
40
    '*.sw[nop]',
 
41
    '*~',
 
42
    '.#*',
 
43
    '[#]*#',
 
44
    '__pycache__',
 
45
    'bzr-orphans',
 
46
]
 
47
 
 
48
 
 
49
 
 
50
def parse_ignore_file(f):
 
51
    """Read in all of the lines in the file and turn it into an ignore list
 
52
    
 
53
    Continue in the case of utf8 decoding errors, and emit a warning when 
 
54
    such and error is found. Optimise for the common case -- no decoding 
 
55
    errors.
 
56
    """
 
57
    ignored = set()
 
58
    ignore_file = f.read()
 
59
    try:
 
60
        # Try and parse whole ignore file at once.
 
61
        unicode_lines = ignore_file.decode('utf8').split('\n')
 
62
    except UnicodeDecodeError:
 
63
        # Otherwise go though line by line and pick out the 'good'
 
64
        # decodable lines
 
65
        lines = ignore_file.split('\n')
 
66
        unicode_lines = []
 
67
        for line_number, line in enumerate(lines):
 
68
            try:
 
69
                unicode_lines.append(line.decode('utf-8'))
 
70
            except UnicodeDecodeError:
 
71
                # report error about line (idx+1)
 
72
                warning('.bzrignore: On Line #%d, malformed utf8 character. '
 
73
                        'Ignoring line.' % (line_number+1))
 
74
 
 
75
    # Append each line to ignore list if it's not a comment line
 
76
    for line in unicode_lines:
 
77
        line = line.rstrip('\r\n')
 
78
        if not line or line.startswith('#'):
 
79
            continue
 
80
        ignored.add(globbing.normalize_pattern(line))
 
81
    return ignored
 
82
 
 
83
 
 
84
def get_user_ignores():
 
85
    """Get the list of user ignored files, possibly creating it."""
 
86
    path = config.user_ignore_config_filename()
 
87
    patterns = set(USER_DEFAULTS)
 
88
    try:
 
89
        f = open(path, 'rb')
 
90
    except (IOError, OSError), e:
 
91
        # open() shouldn't return an IOError without errno, but just in case
 
92
        err = getattr(e, 'errno', None)
 
93
        if err not in (errno.ENOENT,):
 
94
            raise
 
95
        # Create the ignore file, and just return the default
 
96
        # We want to ignore if we can't write to the file
 
97
        # since get_* should be a safe operation
 
98
        try:
 
99
            _set_user_ignores(USER_DEFAULTS)
 
100
        except (IOError, OSError), e:
 
101
            if e.errno not in (errno.EPERM,):
 
102
                raise
 
103
        return patterns
 
104
 
 
105
    try:
 
106
        return parse_ignore_file(f)
 
107
    finally:
 
108
        f.close()
 
109
 
 
110
 
 
111
def _set_user_ignores(patterns):
 
112
    """Fill out the user ignore file with the given patterns
 
113
 
 
114
    This may raise an error if it doesn't have permission to
 
115
    write to the user ignore file.
 
116
    This is mostly used for testing, since it would be
 
117
    bad form to rewrite a user's ignore list.
 
118
    bzrlib only writes this file if it does not exist.
 
119
    """
 
120
    ignore_path = config.user_ignore_config_filename()
 
121
    config.ensure_config_dir_exists()
 
122
 
 
123
    # Create an empty file
 
124
    f = open(ignore_path, 'wb')
 
125
    try:
 
126
        for pattern in patterns:
 
127
            f.write(pattern.encode('utf8') + '\n')
 
128
    finally:
 
129
        f.close()
 
130
 
 
131
 
 
132
def add_unique_user_ignores(new_ignores):
 
133
    """Add entries to the user's ignore list if not present.
 
134
 
 
135
    :param new_ignores: A list of ignore patterns
 
136
    :return: The list of ignores that were added
 
137
    """
 
138
    ignored = get_user_ignores()
 
139
    to_add = []
 
140
    for ignore in new_ignores:
 
141
        ignore = globbing.normalize_pattern(ignore)
 
142
        if ignore not in ignored:
 
143
            ignored.add(ignore)
 
144
            to_add.append(ignore)
 
145
 
 
146
    if not to_add:
 
147
        return []
 
148
 
 
149
    f = open(config.user_ignore_config_filename(), 'ab')
 
150
    try:
 
151
        for pattern in to_add:
 
152
            f.write(pattern.encode('utf8') + '\n')
 
153
    finally:
 
154
        f.close()
 
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(bzrlib.IGNORE_FILENAME)
 
193
    if tree.has_filename(ifn):
 
194
        f = open(ifn, 'rU')
 
195
        try:
 
196
            file_contents = f.read()
 
197
            # figure out what kind of line endings are used
 
198
            newline = getattr(f, 'newlines', None)
 
199
            if type(newline) is tuple:
 
200
                newline = newline[0]
 
201
            elif newline is None:
 
202
                newline = os.linesep
 
203
        finally:
 
204
            f.close()
 
205
    else:
 
206
        file_contents = ""
 
207
        newline = os.linesep
 
208
    
 
209
    sio = StringIO(file_contents)
 
210
    try:
 
211
        ignores = parse_ignore_file(sio)
 
212
    finally:
 
213
        sio.close()
 
214
    
 
215
    # write out the updated ignores set
 
216
    f = atomicfile.AtomicFile(ifn, 'wb')
 
217
    try:
 
218
        # write the original contents, preserving original line endings
 
219
        f.write(newline.join(file_contents.split('\n')))
 
220
        if len(file_contents) > 0 and not file_contents.endswith('\n'):
 
221
            f.write(newline)
 
222
        for pattern in name_pattern_list:
 
223
            if not pattern in ignores:
 
224
                f.write(pattern.encode('utf-8'))
 
225
                f.write(newline)
 
226
        f.commit()
 
227
    finally:
 
228
        f.close()
 
229
 
 
230
    if not tree.path2id(bzrlib.IGNORE_FILENAME):
 
231
        tree.add([bzrlib.IGNORE_FILENAME])