/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 bzrlib/ignores.py

  • Committer: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/ignores.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
17
17
"""Lists of ignore files, etc."""
18
18
 
19
19
import errno
20
 
from io import BytesIO
21
 
import os
22
20
 
23
 
import breezy
24
 
from .lazy_import import lazy_import
25
 
lazy_import(globals(), """
26
 
from breezy import (
 
21
import bzrlib
 
22
from bzrlib import (
27
23
    atomicfile,
 
24
    config,
28
25
    globbing,
29
 
    trace,
30
 
    )
31
 
""")
32
 
from . import (
33
 
    bedding,
34
 
    )
35
 
 
36
 
# ~/.config/breezy/ignore will be filled out using
 
26
    )
 
27
 
 
28
# This was the full ignore list for bzr 0.8
 
29
# please keep these sorted (in C locale order) to aid merging
 
30
OLD_DEFAULTS = [
 
31
    '#*#',
 
32
    '*$',
 
33
    '*,v',
 
34
    '*.BAK',
 
35
    '*.a',
 
36
    '*.bak',
 
37
    '*.elc',
 
38
    '*.exe',
 
39
    '*.la',
 
40
    '*.lo',
 
41
    '*.o',
 
42
    '*.obj',
 
43
    '*.orig',
 
44
    '*.py[oc]',
 
45
    '*.so',
 
46
    '*.tmp',
 
47
    '*~',
 
48
    '.#*',
 
49
    '.*.sw[nop]',
 
50
    '.*.tmp',
 
51
    # Our setup tests dump .python-eggs in the bzr source tree root
 
52
    './.python-eggs',
 
53
    '.DS_Store',
 
54
    '.arch-ids',
 
55
    '.arch-inventory',
 
56
    '.bzr.log',
 
57
    '.del-*',
 
58
    '.git',
 
59
    '.hg',
 
60
    '.jamdeps'
 
61
    '.libs',
 
62
    '.make.state',
 
63
    '.sconsign*',
 
64
    '.svn',
 
65
    '.sw[nop]',    # vim editing nameless file
 
66
    '.tmp*',
 
67
    'BitKeeper',
 
68
    'CVS',
 
69
    'CVS.adm',
 
70
    'RCS',
 
71
    'SCCS',
 
72
    'TAGS',
 
73
    '_darcs',
 
74
    'aclocal.m4',
 
75
    'autom4te*',
 
76
    'config.h',
 
77
    'config.h.in',
 
78
    'config.log',
 
79
    'config.status',
 
80
    'config.sub',
 
81
    'stamp-h',
 
82
    'stamp-h.in',
 
83
    'stamp-h1',
 
84
    '{arch}',
 
85
]
 
86
 
 
87
 
 
88
# ~/.bazaar/ignore will be filled out using
37
89
# this ignore list, if it does not exist
38
90
# please keep these sorted (in C locale order) to aid merging
39
91
USER_DEFAULTS = [
45
97
    '*~',
46
98
    '.#*',
47
99
    '[#]*#',
48
 
    '__pycache__',
49
 
    'bzr-orphans',
50
100
]
51
101
 
52
102
 
53
103
def parse_ignore_file(f):
54
 
    """Read in all of the lines in the file and turn it into an ignore list
55
 
 
56
 
    Continue in the case of utf8 decoding errors, and emit a warning when
57
 
    such and error is found. Optimise for the common case -- no decoding
58
 
    errors.
59
 
    """
 
104
    """Read in all of the lines in the file and turn it into an ignore list"""
60
105
    ignored = set()
61
 
    ignore_file = f.read()
62
 
    try:
63
 
        # Try and parse whole ignore file at once.
64
 
        unicode_lines = ignore_file.decode('utf8').split('\n')
65
 
    except UnicodeDecodeError:
66
 
        # Otherwise go though line by line and pick out the 'good'
67
 
        # decodable lines
68
 
        lines = ignore_file.split(b'\n')
69
 
        unicode_lines = []
70
 
        for line_number, line in enumerate(lines):
71
 
            try:
72
 
                unicode_lines.append(line.decode('utf-8'))
73
 
            except UnicodeDecodeError:
74
 
                # report error about line (idx+1)
75
 
                trace.warning(
76
 
                    '.bzrignore: On Line #%d, malformed utf8 character. '
77
 
                    'Ignoring line.' % (line_number + 1))
78
 
 
79
 
    # Append each line to ignore list if it's not a comment line
80
 
    for line in unicode_lines:
 
106
    for line in f.read().decode('utf8').split('\n'):
81
107
        line = line.rstrip('\r\n')
82
108
        if not line or line.startswith('#'):
83
109
            continue
87
113
 
88
114
def get_user_ignores():
89
115
    """Get the list of user ignored files, possibly creating it."""
90
 
    path = bedding.user_ignore_config_path()
 
116
    path = config.user_ignore_config_filename()
91
117
    patterns = set(USER_DEFAULTS)
92
118
    try:
93
119
        f = open(path, 'rb')
94
 
    except (IOError, OSError) as e:
 
120
    except (IOError, OSError), e:
95
121
        # open() shouldn't return an IOError without errno, but just in case
96
122
        err = getattr(e, 'errno', None)
97
123
        if err not in (errno.ENOENT,):
101
127
        # since get_* should be a safe operation
102
128
        try:
103
129
            _set_user_ignores(USER_DEFAULTS)
104
 
        except EnvironmentError as e:
105
 
            if e.errno not in (errno.EPERM, errno.ENOENT):
 
130
        except (IOError, OSError), e:
 
131
            if e.errno not in (errno.EPERM,):
106
132
                raise
107
133
        return patterns
108
134
 
119
145
    write to the user ignore file.
120
146
    This is mostly used for testing, since it would be
121
147
    bad form to rewrite a user's ignore list.
122
 
    breezy only writes this file if it does not exist.
 
148
    bzrlib only writes this file if it does not exist.
123
149
    """
124
 
    ignore_path = bedding.user_ignore_config_path()
125
 
    bedding.ensure_config_dir_exists()
 
150
    ignore_path = config.user_ignore_config_filename()
 
151
    config.ensure_config_dir_exists()
126
152
 
127
153
    # Create an empty file
128
 
    with open(ignore_path, 'wb') as f:
 
154
    f = open(ignore_path, 'wb')
 
155
    try:
129
156
        for pattern in patterns:
130
 
            f.write(pattern.encode('utf8') + b'\n')
 
157
            f.write(pattern.encode('utf8') + '\n')
 
158
    finally:
 
159
        f.close()
131
160
 
132
161
 
133
162
def add_unique_user_ignores(new_ignores):
147
176
    if not to_add:
148
177
        return []
149
178
 
150
 
    with open(bedding.user_ignore_config_path(), 'ab') as f:
 
179
    f = open(config.user_ignore_config_filename(), 'ab')
 
180
    try:
151
181
        for pattern in to_add:
152
 
            f.write(pattern.encode('utf8') + b'\n')
 
182
            f.write(pattern.encode('utf8') + '\n')
 
183
    finally:
 
184
        f.close()
153
185
 
154
186
    return to_add
155
187
 
178
210
 
179
211
 
180
212
def tree_ignores_add_patterns(tree, name_pattern_list):
181
 
    """Add more ignore patterns to the ignore file in a tree.
182
 
    If ignore file does not exist then it will be created.
183
 
    The ignore file will be automatically added under version control.
 
213
    """Retrieve a list of ignores from the ignore file in a tree.
184
214
 
185
 
    :param tree: Working tree to update the ignore list.
186
 
    :param name_pattern_list: List of ignore patterns.
187
 
    :return: None
 
215
    :param tree: Tree to retrieve the ignore list from.
 
216
    :return:
188
217
    """
189
 
    # read in the existing ignores set
190
 
    ifn = tree.abspath(tree._format.ignore_filename)
 
218
    ifn = tree.abspath(bzrlib.IGNORE_FILENAME)
191
219
    if tree.has_filename(ifn):
192
 
        with open(ifn, 'rb') as f:
193
 
            file_contents = f.read()
194
 
            if file_contents.find(b'\r\n') != -1:
195
 
                newline = b'\r\n'
196
 
            else:
197
 
                newline = b'\n'
 
220
        f = open(ifn, 'rt')
 
221
        try:
 
222
            igns = f.read().decode('utf-8')
 
223
        finally:
 
224
            f.close()
198
225
    else:
199
 
        file_contents = b""
200
 
        newline = os.linesep.encode()
201
 
 
202
 
    with BytesIO(file_contents) as sio:
203
 
        ignores = parse_ignore_file(sio)
204
 
 
205
 
    # write out the updated ignores set
206
 
    with atomicfile.AtomicFile(ifn, 'wb') as f:
207
 
        # write the original contents, preserving original line endings
208
 
        f.write(file_contents)
209
 
        if len(file_contents) > 0 and not file_contents.endswith(b'\n'):
210
 
            f.write(newline)
211
 
        for pattern in name_pattern_list:
212
 
            if pattern not in ignores:
213
 
                f.write(pattern.encode('utf-8'))
214
 
                f.write(newline)
215
 
 
216
 
    if not tree.is_versioned(tree._format.ignore_filename):
217
 
        tree.add([tree._format.ignore_filename])
 
226
        igns = ""
 
227
 
 
228
    # TODO: If the file already uses crlf-style termination, maybe
 
229
    # we should use that for the newly added lines?
 
230
 
 
231
    if igns and igns[-1] != '\n':
 
232
        igns += '\n'
 
233
    for name_pattern in name_pattern_list:
 
234
        igns += name_pattern + '\n'
 
235
 
 
236
    f = atomicfile.AtomicFile(ifn, 'wb')
 
237
    try:
 
238
        f.write(igns.encode('utf-8'))
 
239
        f.commit()
 
240
    finally:
 
241
        f.close()
 
242
 
 
243
    if not tree.path2id('.bzrignore'):
 
244
        tree.add(['.bzrignore'])