1
=== modified file 'TODO'
2
--- TODO	2009-04-15 14:10:19 +0000
3
+++ TODO	2010-08-13 01:14:42 +0000
4
@@ -1,6 +1,3 @@
5
1
- Implement building the source package from the tree, including adding
6
2
  the changelog entry with the desired version.
7
3
- Implement uploading to a PPA.
8
4
- Documentation.
1
- Documentation.
9
5
- Work out how to get tarballs for non-native packages if we want that.
2
- Work out how to get tarballs for non-native packages if we want that.
10
6
- Decide on error on existing target directory vs. re-use and pull changes.
3
- Decide on error on existing target directory vs. re-use and pull changes.
11
7
4
12
=== modified file '__init__.py'
13
--- __init__.py	2010-08-13 01:14:42 +0000
14
+++ __init__.py	2010-08-13 01:14:42 +0000
15
@@ -21,7 +21,7 @@
16
21
21
17
22
A recipe is just a text file that starts with a line such as::
22
A recipe is just a text file that starts with a line such as::
18
23
23
20
24
  # bzr-builder format 0.2 deb-version 1.0+{revno}-{revno:packaging}
24
  # bzr-builder format 0.3 deb-version 1.0+{revno}-{revno:packaging}
21
25
25
22
26
The format specifier is there to allow the syntax to be changed in later
26
The format specifier is there to allow the syntax to be changed in later
23
27
versions, and the meaning of "deb-version" will be explained later.
27
versions, and the meaning of "deb-version" will be explained later.
24
@@ -70,6 +70,20 @@
25
70
for the revisionspec is identical to that taken by the "--revision" argument
70
for the revisionspec is identical to that taken by the "--revision" argument
26
71
to many bzr commands. See "bzr help revisionspec" for details.
71
to many bzr commands. See "bzr help revisionspec" for details.
27
72
72
28
73
You can also merge specific subdirectories from a branch with a "nest-part"
29
74
line like
30
75
31
76
nest-part packaging lp:~foo-dev/foo/packaging debian
32
77
33
78
which specifies that the only the debian/ subdirectory should be merged.  This
34
79
works even if the branches share no revision history.  You can optionally
35
80
specify the subdirectory and revision in the target with a line like
36
81
37
82
nest-part libfoo lp:libfoo src lib/foo tag:release-1.2
38
83
39
84
which will put the "src" directory of libfoo in "lib/foo", using the revision
40
85
of libfoo tagged "release-1.2".
41
86
42
73
It is also possible to run an arbitrary command at a particular point in the
87
It is also possible to run an arbitrary command at a particular point in the
43
74
construction process. For example::
88
construction process. For example::
44
75
89
45
@@ -104,14 +118,28 @@
46
104
118
47
105
  * {time} will be substituted with the current date and time, such as
119
  * {time} will be substituted with the current date and time, such as
48
106
    200908191512.
120
    200908191512.
49
121
  * {date} will be substituted with just the current date, such as
50
122
    20090819.
51
107
  * {revno} will be the revno of the base branch (the first specified).
123
  * {revno} will be the revno of the base branch (the first specified).
52
108
  * {revno:<branch name>} will be substituted with the revno for the
124
  * {revno:<branch name>} will be substituted with the revno for the
53
109
    branch named <branch name> in the recipe.
125
    branch named <branch name> in the recipe.
54
126
  * {debupstream} will be replaced by the upstream portion of the version
55
127
    number taken from debian/changelog in the final tree. If when the
56
128
    tree is built the top of debian/changelog has a version number of
57
129
    "1.0-1" then this would evaluate to "1.0".
58
130
59
131
Instruction syntax summary:
60
132
61
133
  * nest NAME BRANCH TARGET-DIR [REVISION]
62
134
  * merge NAME BRANCH [REVISION]
63
135
  * nest-part NAME BRANCH SUBDIR [TARGET-DIR [REVISION]]
64
136
  * run COMMAND
65
110
137
66
111
Format versions:
138
Format versions:
67
112
139
68
113
  0.1 - original format.
140
  0.1 - original format.
69
114
  0.2 - added "run" instruction.
141
  0.2 - added "run" instruction.
70
142
  0.3 - added "nest-part" instruction.
71
115
"""
143
"""
72
116
144
73
117
if __name__ == '__main__':
145
if __name__ == '__main__':
74
@@ -123,382 +151,10 @@
75
123
            shell=True, env={"BZR_PLUGIN_PATH": dir})
151
            shell=True, env={"BZR_PLUGIN_PATH": dir})
76
124
    sys.exit(retcode)
152
    sys.exit(retcode)
77
125
153
454
126
import datetime
154
455
127
from email import utils
155
from bzrlib.commands import plugin_cmds
456
128
import os
156
plugin_cmds.register_lazy("cmd_build", [], "bzrlib.plugins.builder.cmds")
457
129
import pwd
157
plugin_cmds.register_lazy("cmd_dailydeb", [], "bzrlib.plugins.builder.cmds")
82
130
import re
83
131
import socket
84
132
import shutil
85
133
import subprocess
86
134
import tempfile
87
135
88
136
from debian_bundle import changelog
89
137
90
138
from bzrlib import (
91
139
        errors,
92
140
        trace,
93
141
        transport,
94
142
        )
95
143
from bzrlib.commands import Command, register_command
96
144
from bzrlib.option import Option
97
145
98
146
from bzrlib.plugins.builder.recipe import (
99
147
        build_manifest,
100
148
        build_tree,
101
149
        RecipeParser,
102
150
        resolve_revisions,
103
151
        )
104
152
105
153
106
154
def write_manifest_to_path(path, base_branch):
107
155
    parent_dir = os.path.dirname(path)
108
156
    if parent_dir != '' and not os.path.exists(parent_dir):
109
157
        os.makedirs(parent_dir)
110
158
    manifest_f = open(path, 'wb')
111
159
    try:
112
160
        manifest_f.write(build_manifest(base_branch))
113
161
    finally:
114
162
        manifest_f.close()
115
163
116
164
117
165
def get_branch_from_recipe_file(recipe_file):
118
166
    recipe_transport = transport.get_transport(os.path.dirname(recipe_file))
119
167
    try:
120
168
        recipe_contents = recipe_transport.get_bytes(
121
169
                os.path.basename(recipe_file))
122
170
    except errors.NoSuchFile:
123
171
        raise errors.BzrCommandError("Specified recipe does not exist: "
124
172
                "%s" % recipe_file)
125
173
    parser = RecipeParser(recipe_contents, filename=recipe_file)
126
174
    return parser.parse()
127
175
128
176
129
177
def get_old_recipe(if_changed_from):
130
178
    old_manifest_transport = transport.get_transport(os.path.dirname(
131
179
                if_changed_from))
132
180
    try:
133
181
        old_manifest_contents = old_manifest_transport.get_bytes(
134
182
                os.path.basename(if_changed_from))
135
183
    except errors.NoSuchFile:
136
184
        return None
137
185
    old_recipe = RecipeParser(old_manifest_contents,
138
186
            filename=if_changed_from).parse()
139
187
    return old_recipe
140
188
141
189
142
190
def get_maintainer():
143
191
    """
144
192
    Create maintainer string using the same algorithm as in dch
145
193
    """
146
194
    env = os.environ
147
195
    regex = re.compile(r"^(.*)\s+<(.*)>$")
148
196
149
197
    # Split email and name
150
198
    if 'DEBEMAIL' in env:
151
199
        match_obj = regex.match(env['DEBEMAIL'])
152
200
        if match_obj:
153
201
            if not 'DEBFULLNAME' in env:
154
202
                env['DEBFULLNAME'] = match_obj.group(1)
155
203
            env['DEBEMAIL'] = match_obj.group(2)
156
204
    if 'DEBEMAIL' not in env or 'DEBFULLNAME' not in env:
157
205
        if 'EMAIL' in env:
158
206
            match_obj = regex.match(env['EMAIL'])
159
207
            if match_obj:
160
208
                if not 'DEBFULLNAME' in env:
161
209
                    env['DEBFULLNAME'] = match_obj.group(1)
162
210
                env['EMAIL'] = match_obj.group(2)
163
211
164
212
    # Get maintainer's name
165
213
    if 'DEBFULLNAME' in env:
166
214
        maintainer = env['DEBFULLNAME']
167
215
    elif 'NAME' in env:
168
216
        maintainer = env['NAME']
169
217
    else:
170
218
        # Use password database if no data in environment variables
171
219
        try:
172
220
            maintainer = re.sub(r',.*', '', pwd.getpwuid(os.getuid()).pw_gecos)
173
221
        except KeyError, AttributeError:
174
222
            # TBD: Use last changelog entry value
175
223
            maintainer = "bzr-builder"
176
224
177
225
    # Get maintainer's mail address
178
226
    if 'DEBEMAIL' in env:
179
227
        email = env['DEBEMAIL']
180
228
    elif 'EMAIL' in env:
181
229
        email = env['EMAIL']
182
230
    else:
183
231
        addr = None
184
232
        if os.path.exists('/etc/mailname'):
185
233
            f = open('/etc/mailname')
186
234
            try:
187
235
                addr = f.readline().strip()
188
236
            finally:
189
237
                f.close()
190
238
        if not addr:
191
239
            addr = socket.getfqdn()
192
240
        if addr:
193
241
            user = pwd.getpwuid(os.getuid()).pw_name
194
242
            if not user:
195
243
                addr = None
196
244
            else:
197
245
                addr = "%s@%s" % (user, addr)
198
246
199
247
        if addr:
200
248
            email = addr
201
249
        else:
202
250
            # TBD: Use last changelog entry value
203
251
            email = "none@example.org"
204
252
205
253
    return (maintainer, email)
206
254
207
255
208
256
def add_changelog_entry(base_branch, basedir, distribution=None,
209
257
        package=None):
210
258
    debian_dir = os.path.join(basedir, "debian")
211
259
    if not os.path.exists(debian_dir):
212
260
        os.makedirs(debian_dir)
213
261
    cl_path = os.path.join(debian_dir, "changelog")
214
262
    if os.path.exists(cl_path):
215
263
        cl_f = open(cl_path)
216
264
        try:
217
265
            cl = changelog.Changelog(file=cl_f)
218
266
        finally:
219
267
            cl_f.close()
220
268
    else:
221
269
        cl = changelog.Changelog()
222
270
    if len(cl._blocks) > 0:
223
271
        if distribution is None:
224
272
            distribution = cl._blocks[0].distributions.split()[0]
225
273
        if package is None:
226
274
            package = cl._blocks[0].package
227
275
        if "{debupstream}" in base_branch.deb_version:
228
276
            cl_version = cl._blocks[0].version
229
277
            base_branch.deb_version = base_branch.deb_version.replace(
230
278
                "{debupstream}", cl_version.upstream_version)
231
279
    else:
232
280
        if package is None:
233
281
            raise errors.BzrCommandError("No previous changelog to "
234
282
                    "take the package name from, and --package not "
235
283
                    "specified.")
236
284
        if "{debupstream}" in base_branch.deb_version:
237
285
            raise errors.BzrCommandError("No previous changelog to "
238
286
                    "take the upstream version from - {debupstream} was "
239
287
                    "used.")
240
288
        if distribution is None:
241
289
            distribution = "jaunty"
242
290
    # Use debian packaging environment variables
243
291
    # or default values if they don't exist
244
292
    author = "%s <%s>" % get_maintainer()
245
293
246
294
    date = utils.formatdate(localtime=True)
247
295
    cl.new_block(package=package, version=base_branch.deb_version,
248
296
            distributions=distribution, urgency="low",
249
297
            changes=['', '  * Auto build.', ''],
250
298
            author=author, date=date)
251
299
    cl_f = open(cl_path, 'wb')
252
300
    try:
253
301
        cl.write_to_open_file(cl_f)
254
302
    finally:
255
303
        cl_f.close()
256
304
257
305
258
306
def build_source_package(basedir):
259
307
    trace.note("Building the source package")
260
308
    command = ["/usr/bin/debuild", "--no-tgz-check", "-i", "-I", "-S",
261
309
                    "-uc", "-us"]
262
310
    proc = subprocess.Popen(command, cwd=basedir,
263
311
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
264
312
            stdin=subprocess.PIPE)
265
313
    proc.stdin.close()
266
314
    retcode = proc.wait()
267
315
    if retcode != 0:
268
316
        output = proc.stdout.read()
269
317
        raise errors.BzrCommandError("Failed to build the source package: "
270
318
                "%s" % output)
271
319
272
320
273
321
def sign_source_package(basedir, key_id):
274
322
    trace.note("Signing the source package")
275
323
    command = ["/usr/bin/debsign", "-S", "-k%s" % key_id]
276
324
    proc = subprocess.Popen(command, cwd=basedir,
277
325
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
278
326
            stdin=subprocess.PIPE)
279
327
    proc.stdin.close()
280
328
    retcode = proc.wait()
281
329
    if retcode != 0:
282
330
        output = proc.stdout.read()
283
331
        raise errors.BzrCommandError("Signing the package failed: "
284
332
                "%s" % output)
285
333
286
334
287
335
def dput_source_package(basedir, target):
288
336
    trace.note("Uploading the source package")
289
337
    command = ["/usr/bin/debrelease", "-S", "--dput", target]
290
338
    proc = subprocess.Popen(command, cwd=basedir,
291
339
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
292
340
            stdin=subprocess.PIPE)
293
341
    proc.stdin.close()
294
342
    retcode = proc.wait()
295
343
    if retcode != 0:
296
344
        output = proc.stdout.read()
297
345
        raise errors.BzrCommandError("Uploading the package failed: "
298
346
                "%s" % output)
299
347
300
348
301
349
class cmd_build(Command):
302
350
    """Build a tree based on a 'recipe'.
303
351
304
352
    Pass the name of the recipe file and the directory to work in.
305
353
306
354
    See "bzr help builder" for more information on what a recipe is.
307
355
    """
308
356
    takes_args = ["recipe_file", "working_directory"]
309
357
    takes_options = [
310
358
            Option('manifest', type=str, argname="path",
311
359
                   help="Path to write the manifest to."),
312
360
            Option('if-changed-from', type=str, argname="path",
313
361
                   help="Only build if the outcome would be different "
314
362
                        "to that specified in the specified manifest."),
315
363
                    ]
316
364
317
365
    def _substitute_stuff(self, recipe_file, if_changed_from):
318
366
        """Common code to substitute stuff
319
367
        
320
368
        :return: A tuple with (retcode, base_branch). If retcode is None
321
369
            then the command execution should continue.
322
370
        """
323
371
        base_branch = get_branch_from_recipe_file(recipe_file)
324
372
        time = datetime.datetime.utcnow()
325
373
        base_branch.substitute_time(time)
326
374
        old_recipe = None
327
375
        if if_changed_from is not None:
328
376
            old_recipe = get_old_recipe(if_changed_from)
329
377
        # Save the unsubstituted version for dailydeb.
330
378
        self._template_version = base_branch.deb_version
331
379
        changed = resolve_revisions(base_branch, if_changed_from=old_recipe)
332
380
        if not changed:
333
381
            trace.note("Unchanged")
334
382
            return 0, base_branch
335
383
        return None, base_branch
336
384
337
385
    def run(self, recipe_file, working_directory, manifest=None,
338
386
            if_changed_from=None):
339
387
        result, base_branch = self._substitute_stuff(recipe_file,
340
388
            if_changed_from)
341
389
        if result is not None:
342
390
            return result
343
391
        manifest_path = manifest or os.path.join(working_directory,
344
392
                        "bzr-builder.manifest")
345
393
        build_tree(base_branch, working_directory)
346
394
        write_manifest_to_path(manifest_path, base_branch)
347
395
348
396
349
397
register_command(cmd_build)
350
398
351
399
352
400
class cmd_dailydeb(cmd_build):
353
401
    """Build a deb based on a 'recipe'.
354
402
355
403
    See "bzr help builder" for more information on what a recipe is.
356
404
357
405
    If you do not specify a working directory then a temporary
358
406
    directory will be used and it will be removed when the command
359
407
    finishes.
360
408
    """
361
409
362
410
    takes_options = cmd_build.takes_options + [
363
411
                Option("package", type=str,
364
412
                       help="The package name to use in the changelog entry. "
365
413
                            "If not specified then the package from the "
366
414
                            "previous changelog entry will be used, so it "
367
415
                            "must be specified if there is no changelog."),
368
416
                Option("distribution", type=str,
369
417
                        help="The distribution to target. If not specified "
370
418
                             "then the same distribution as the last entry "
371
419
                             "in debian/changelog will be used."),
372
420
                Option("dput", type=str, argname="target",
373
421
                        help="dput the built package to the specified "
374
422
                        "dput target."),
375
423
                Option("key-id", type=str, short_name="k",
376
424
                       help="Sign the packages with the specified GnuPG key, "
377
425
                            "must be specified if you use --dput."),
378
426
            ]
379
427
380
428
    takes_args = ["recipe_file", "working_basedir?"]
381
429
382
430
    def run(self, recipe_file, working_basedir=None, manifest=None,
383
431
            if_changed_from=None, package=None, distribution=None,
384
432
            dput=None, key_id=None):
385
433
386
434
        if dput is not None and key_id is None:
387
435
            raise errors.BzrCommandError("You must specify --key-id if you "
388
436
                    "specify --dput.")
389
437
        result, base_branch = self._substitute_stuff(recipe_file,
390
438
            if_changed_from)
391
439
        if result is not None:
392
440
            return result
393
441
        if working_basedir is None:
394
442
            temp_dir = tempfile.mkdtemp(prefix="bzr-builder-")
395
443
            working_basedir = temp_dir
396
444
        else:
397
445
            temp_dir = None
398
446
            if not os.path.exists(working_basedir):
399
447
                os.makedirs(working_basedir)
400
448
        self._calculate_package_name(recipe_file, package)
401
449
        working_directory = os.path.join(working_basedir,
402
450
            "%s-%s" % (self._package_name, self._template_version))
403
451
        try:
404
452
            # we want to use a consistent package_dir always to support
405
453
            # updates in place, but debuild etc want PACKAGE-UPSTREAMVERSION
406
454
            # on disk, so we build_tree with the unsubstituted version number
407
455
            # and do a final rename-to step before calling into debian build
408
456
            # tools. We then rename the working dir back.
409
457
            manifest_path = os.path.join(working_directory, "debian",
410
458
                "bzr-builder.manifest")
411
459
            build_tree(base_branch, working_directory)
412
460
            write_manifest_to_path(manifest_path, base_branch)
413
461
            # Add changelog also substitutes {debupstream}.
414
462
            add_changelog_entry(base_branch, working_directory,
415
463
                distribution=distribution, package=package)
416
464
            package_dir = self._calculate_package_dir(base_branch,
417
465
                working_basedir)
418
466
            # working_directory -> package_dir: after this debian stuff works.
419
467
            os.rename(working_directory, package_dir)
420
468
            try:
421
469
                build_source_package(package_dir)
422
470
                if key_id is not None:
423
471
                    sign_source_package(package_dir, key_id)
424
472
                if dput is not None:
425
473
                    dput_source_package(package_dir, dput)
426
474
            finally:
427
475
                # package_dir -> working_directory
428
476
                os.rename(package_dir, working_directory)
429
477
            # Note that this may write a second manifest.
430
478
            if manifest is not None:
431
479
                write_manifest_to_path(manifest, base_branch)
432
480
        finally:
433
481
            if temp_dir is not None:
434
482
                shutil.rmtree(temp_dir)
435
483
436
484
    def _calculate_package_dir(self, base_branch, working_basedir):
437
485
        """Calculate the directory name that should be used while debuilding."""
438
486
        version = base_branch.deb_version
439
487
        if "-" in version:
440
488
            version = version[:version.rindex("-")]
441
489
        package_basedir = "%s-%s" % (self._package_name, version)
442
490
        package_dir = os.path.join(working_basedir, package_basedir)
443
491
        return package_dir
444
492
445
493
    def _calculate_package_name(self, recipe_file, package):
446
494
        """Calculate the directory name that should be used while debuilding."""
447
495
        recipe_name = os.path.basename(recipe_file)
448
496
        if recipe_name.endswith(".recipe"):
449
497
            recipe_name = recipe_name[:-len(".recipe")]
450
498
        self._package_name = package or recipe_name
451
499
452
500
453
501
register_command(cmd_dailydeb)
458
502
158
459
503
159
460
504
def test_suite():
160
def test_suite():
461
505
161
462
=== added file 'cmds.py'
463
--- cmds.py	1970-01-01 00:00:00 +0000
464
+++ cmds.py	2010-08-13 01:14:42 +0000
465
@@ -0,0 +1,492 @@
466
1
# bzr-builder: a bzr plugin to constuct trees based on recipes
467
2
# Copyright 2009 Canonical Ltd.
468
3
469
4
# This program is free software: you can redistribute it and/or modify it 
470
5
# under the terms of the GNU General Public License version 3, as published 
471
6
# by the Free Software Foundation.
472
7
473
8
# This program is distributed in the hope that it will be useful, but 
474
9
# WITHOUT ANY WARRANTY; without even the implied warranties of 
475
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
476
11
# PURPOSE.  See the GNU General Public License for more details.
477
12
478
13
# You should have received a copy of the GNU General Public License along 
479
14
# with this program.  If not, see <http://www.gnu.org/licenses/>.
480
15
481
16
"""Subcommands provided by bzr-builder."""
482
17
483
18
import datetime
484
19
from email import utils
485
20
import errno
486
21
import os
487
22
import pwd
488
23
import re
489
24
import socket
490
25
import shutil
491
26
import subprocess
492
27
import tempfile
493
28
494
29
try:
495
30
    from debian import changelog
496
31
except ImportError:
497
32
    # In older versions of python-debian the main package was named 
498
33
    # debian_bundle
499
34
    from debian_bundle import changelog
500
35
501
36
from bzrlib import (
502
37
        errors,
503
38
        trace,
504
39
        transport,
505
40
        )
506
41
from bzrlib.commands import Command
507
42
from bzrlib.option import Option
508
43
509
44
from bzrlib.plugins.builder.recipe import (
510
45
        build_tree,
511
46
        DEBUPSTREAM_VAR,
512
47
        RecipeParser,
513
48
        resolve_revisions,
514
49
        )
515
50
516
51
517
52
# The default distribution used by add_changelog_entry()
518
53
DEFAULT_UBUNTU_DISTRIBUTION = "lucid"
519
54
520
55
521
56
class MissingDependency(errors.BzrError):
522
57
    pass
523
58
524
59
525
60
def write_manifest_to_path(path, base_branch):
526
61
    parent_dir = os.path.dirname(path)
527
62
    if parent_dir != '' and not os.path.exists(parent_dir):
528
63
        os.makedirs(parent_dir)
529
64
    manifest_f = open(path, 'wb')
530
65
    try:
531
66
        manifest_f.write(str(base_branch))
532
67
    finally:
533
68
        manifest_f.close()
534
69
535
70
536
71
def get_branch_from_recipe_file(recipe_file):
537
72
    recipe_transport = transport.get_transport(os.path.dirname(recipe_file))
538
73
    try:
539
74
        recipe_contents = recipe_transport.get_bytes(
540
75
                os.path.basename(recipe_file))
541
76
    except errors.NoSuchFile:
542
77
        raise errors.BzrCommandError("Specified recipe does not exist: "
543
78
                "%s" % recipe_file)
544
79
    parser = RecipeParser(recipe_contents, filename=recipe_file)
545
80
    return parser.parse()
546
81
547
82
548
83
def get_old_recipe(if_changed_from):
549
84
    old_manifest_transport = transport.get_transport(os.path.dirname(
550
85
                if_changed_from))
551
86
    try:
552
87
        old_manifest_contents = old_manifest_transport.get_bytes(
553
88
                os.path.basename(if_changed_from))
554
89
    except errors.NoSuchFile:
555
90
        return None
556
91
    old_recipe = RecipeParser(old_manifest_contents,
557
92
            filename=if_changed_from).parse()
558
93
    return old_recipe
559
94
560
95
561
96
def get_maintainer():
562
97
    """Create maintainer string using the same algorithm as in dch.
563
98
    """
564
99
    env = os.environ
565
100
    regex = re.compile(r"^(.*)\s+<(.*)>$")
566
101
567
102
    # Split email and name
568
103
    if 'DEBEMAIL' in env:
569
104
        match_obj = regex.match(env['DEBEMAIL'])
570
105
        if match_obj:
571
106
            if not 'DEBFULLNAME' in env:
572
107
                env['DEBFULLNAME'] = match_obj.group(1)
573
108
            env['DEBEMAIL'] = match_obj.group(2)
574
109
    if 'DEBEMAIL' not in env or 'DEBFULLNAME' not in env:
575
110
        if 'EMAIL' in env:
576
111
            match_obj = regex.match(env['EMAIL'])
577
112
            if match_obj:
578
113
                if not 'DEBFULLNAME' in env:
579
114
                    env['DEBFULLNAME'] = match_obj.group(1)
580
115
                env['EMAIL'] = match_obj.group(2)
581
116
582
117
    # Get maintainer's name
583
118
    if 'DEBFULLNAME' in env:
584
119
        maintainer = env['DEBFULLNAME']
585
120
    elif 'NAME' in env:
586
121
        maintainer = env['NAME']
587
122
    else:
588
123
        # Use password database if no data in environment variables
589
124
        try:
590
125
            maintainer = re.sub(r',.*', '', pwd.getpwuid(os.getuid()).pw_gecos)
591
126
        except (KeyError, AttributeError):
592
127
            # TBD: Use last changelog entry value
593
128
            maintainer = "bzr-builder"
594
129
595
130
    # Get maintainer's mail address
596
131
    if 'DEBEMAIL' in env:
597
132
        email = env['DEBEMAIL']
598
133
    elif 'EMAIL' in env:
599
134
        email = env['EMAIL']
600
135
    else:
601
136
        addr = None
602
137
        if os.path.exists('/etc/mailname'):
603
138
            f = open('/etc/mailname')
604
139
            try:
605
140
                addr = f.readline().strip()
606
141
            finally:
607
142
                f.close()
608
143
        if not addr:
609
144
            addr = socket.getfqdn()
610
145
        if addr:
611
146
            user = pwd.getpwuid(os.getuid()).pw_name
612
147
            if not user:
613
148
                addr = None
614
149
            else:
615
150
                addr = "%s@%s" % (user, addr)
616
151
617
152
        if addr:
618
153
            email = addr
619
154
        else:
620
155
            # TBD: Use last changelog entry value
621
156
            email = "none@example.org"
622
157
623
158
    return (maintainer, email)
624
159
625
160
626
161
def add_changelog_entry(base_branch, basedir, distribution=None,
627
162
        package=None, author_name=None, author_email=None,
628
163
        append_version=None):
629
164
    debian_dir = os.path.join(basedir, "debian")
630
165
    if not os.path.exists(debian_dir):
631
166
        os.makedirs(debian_dir)
632
167
    cl_path = os.path.join(debian_dir, "changelog")
633
168
    file_found = False
634
169
    if os.path.exists(cl_path):
635
170
        file_found = True
636
171
        cl_f = open(cl_path)
637
172
        try:
638
173
            contents = cl_f.read()
639
174
        finally:
640
175
            cl_f.close()
641
176
        cl = changelog.Changelog(file=contents)
642
177
    else:
643
178
        cl = changelog.Changelog()
644
179
    if len(cl._blocks) > 0:
645
180
        if distribution is None:
646
181
            distribution = cl._blocks[0].distributions.split()[0]
647
182
        if package is None:
648
183
            package = cl._blocks[0].package
649
184
        if DEBUPSTREAM_VAR in base_branch.deb_version:
650
185
            cl_version = cl._blocks[0].version
651
186
            base_branch.substitute_debupstream(cl_version)
652
187
    else:
653
188
        if file_found:
654
189
            if len(contents.strip()) > 0:
655
190
                reason = ("debian/changelog didn't contain any "
656
191
                         "parseable stanzas")
657
192
            else:
658
193
                reason = "debian/changelog was empty"
659
194
        else:
660
195
            reason = "debian/changelog was not present"
661
196
        if package is None:
662
197
            raise errors.BzrCommandError("No previous changelog to "
663
198
                    "take the package name from, and --package not "
664
199
                    "specified: %s." % reason)
665
200
        if DEBUPSTREAM_VAR in base_branch.deb_version:
666
201
            raise errors.BzrCommandError("No previous changelog to "
667
202
                    "take the upstream version from as %s was "
668
203
                    "used: %s." % (DEBUPSTREAM_VAR, reason))
669
204
        if distribution is None:
670
205
            distribution = DEFAULT_UBUNTU_DISTRIBUTION
671
206
    # Use debian packaging environment variables
672
207
    # or default values if they don't exist
673
208
    if author_name is None or author_email is None:
674
209
        author_name, author_email = get_maintainer()
675
210
    author = "%s <%s>" % (author_name, author_email)
676
211
677
212
    date = utils.formatdate(localtime=True)
678
213
    version = base_branch.deb_version
679
214
    if append_version is not None:
680
215
        version += append_version
681
216
    try:
682
217
        changelog.Version(version)
683
218
    except (changelog.VersionError, ValueError), e:
684
219
        raise errors.BzrCommandError("Invalid deb-version: %s: %s"
685
220
                % (version, e))
686
221
    cl.new_block(package=package, version=version,
687
222
            distributions=distribution, urgency="low",
688
223
            changes=['', '  * Auto build.', ''],
689
224
            author=author, date=date)
690
225
    cl_f = open(cl_path, 'wb')
691
226
    try:
692
227
        cl.write_to_open_file(cl_f)
693
228
    finally:
694
229
        cl_f.close()
695
230
696
231
697
232
def calculate_package_dir(base_branch, package_name, working_basedir):
698
233
    """Calculate the directory name that should be used while debuilding."""
699
234
    version = base_branch.deb_version
700
235
    if "-" in version:
701
236
        version = version[:version.rindex("-")]
702
237
    package_basedir = "%s-%s" % (package_name, version)
703
238
    package_dir = os.path.join(working_basedir, package_basedir)
704
239
    return package_dir
705
240
706
241
707
242
def _run_command(command, basedir, msg, error_msg,
708
243
        not_installed_msg=None):
709
244
    """ Run a command in a subprocess.
710
245
711
246
    :param command: list with command and parameters
712
247
    :param msg: message to display to the user
713
248
    :param error_msg: message to display if something fails.
714
249
    :param not_installed_msg: the message to display if the command
715
250
        isn't available.
716
251
    """
717
252
    trace.note(msg)
718
253
    # Hide output if -q is in use.
719
254
    quiet = trace.is_quiet()
720
255
    if quiet:
721
256
        kwargs = {"stderr": subprocess.STDOUT, "stdout": subprocess.PIPE}
722
257
    else:
723
258
        kwargs = {}
724
259
    try:
725
260
        proc = subprocess.Popen(command, cwd=basedir,
726
261
                stdin=subprocess.PIPE, **kwargs)
727
262
    except OSError, e:
728
263
        if e.errno != errno.ENOENT:
729
264
            raise
730
265
        if not_installed_msg is None:
731
266
            raise
732
267
        raise MissingDependency(msg=not_installed_msg)
733
268
    output = proc.communicate()
734
269
    if proc.returncode != 0:
735
270
        if quiet:
736
271
            raise errors.BzrCommandError("%s: %s" % (error_msg, output))
737
272
        else:
738
273
            raise errors.BzrCommandError(error_msg)
739
274
740
275
741
276
def build_source_package(basedir):
742
277
    command = ["/usr/bin/debuild", "--no-tgz-check", "-i", "-I", "-S",
743
278
                    "-uc", "-us"]
744
279
    _run_command(command, basedir,
745
280
        "Building the source package",
746
281
        "Failed to build the source package",
747
282
        not_installed_msg="debuild is not installed, please install "
748
283
            "the devscripts package.")
749
284
750
285
751
286
def sign_source_package(basedir, key_id):
752
287
    command = ["/usr/bin/debsign", "-S", "-k%s" % key_id]
753
288
    _run_command(command, basedir,
754
289
        "Signing the source package",
755
290
        "Signing the package failed",
756
291
        not_installed_msg="debsign is not installed, please install "
757
292
            "the devscripts package.")
758
293
759
294
760
295
def dput_source_package(basedir, target):
761
296
    command = ["/usr/bin/debrelease", "-S", "--dput", target]
762
297
    _run_command(command, basedir,
763
298
        "Uploading the source package",
764
299
        "Uploading the package failed",
765
300
        not_installed_msg="debrelease is not installed, please "
766
301
            "install the devscripts package.")
767
302
768
303
769
304
class cmd_build(Command):
770
305
    """Build a tree based on a 'recipe'.
771
306
772
307
    Pass the name of the recipe file and the directory to work in.
773
308
774
309
    See "bzr help builder" for more information on what a recipe is.
775
310
    """
776
311
    takes_args = ["recipe_file", "working_directory"]
777
312
    takes_options = [
778
313
            Option('manifest', type=str, argname="path",
779
314
                   help="Path to write the manifest to."),
780
315
            Option('if-changed-from', type=str, argname="path",
781
316
                   help="Only build if the outcome would be different "
782
317
                        "to that specified in the specified manifest."),
783
318
                    ]
784
319
785
320
    def _get_prepared_branch_from_recipe(self, recipe_file,
786
321
            if_changed_from=None):
787
322
        """Common code to prepare a branch and do substitutions.
788
323
789
324
        :param recipe_file: a path to a recipe file to work from.
790
325
        :param if_changed_from: an optional path to a manifest to
791
326
            compare the recipe against.
792
327
        :return: A tuple with (retcode, base_branch). If retcode is None
793
328
            then the command execution should continue.
794
329
        """
795
330
        base_branch = get_branch_from_recipe_file(recipe_file)
796
331
        time = datetime.datetime.utcnow()
797
332
        base_branch.substitute_time(time)
798
333
        old_recipe = None
799
334
        if if_changed_from is not None:
800
335
            old_recipe = get_old_recipe(if_changed_from)
801
336
        # Save the unsubstituted version for dailydeb.
802
337
        self._template_version = base_branch.deb_version
803
338
        changed = resolve_revisions(base_branch, if_changed_from=old_recipe)
804
339
        if not changed:
805
340
            trace.note("Unchanged")
806
341
            return 0, base_branch
807
342
        return None, base_branch
808
343
809
344
    def run(self, recipe_file, working_directory, manifest=None,
810
345
            if_changed_from=None):
811
346
        result, base_branch = self._get_prepared_branch_from_recipe(recipe_file,
812
347
            if_changed_from=if_changed_from)
813
348
        if result is not None:
814
349
            return result
815
350
        manifest_path = manifest or os.path.join(working_directory,
816
351
                        "bzr-builder.manifest")
817
352
        build_tree(base_branch, working_directory)
818
353
        write_manifest_to_path(manifest_path, base_branch)
819
354
820
355
821
356
class cmd_dailydeb(cmd_build):
822
357
    """Build a deb based on a 'recipe'.
823
358
824
359
    See "bzr help builder" for more information on what a recipe is.
825
360
826
361
    If you do not specify a working directory then a temporary
827
362
    directory will be used and it will be removed when the command
828
363
    finishes.
829
364
    """
830
365
831
366
    takes_options = cmd_build.takes_options + [
832
367
                Option("package", type=str,
833
368
                       help="The package name to use in the changelog entry. "
834
369
                            "If not specified then the package from the "
835
370
                            "previous changelog entry will be used, so it "
836
371
                            "must be specified if there is no changelog."),
837
372
                Option("distribution", type=str,
838
373
                        help="The distribution to target. If not specified "
839
374
                             "then the same distribution as the last entry "
840
375
                             "in debian/changelog will be used."),
841
376
                Option("dput", type=str, argname="target",
842
377
                        help="dput the built package to the specified "
843
378
                        "dput target."),
844
379
                Option("key-id", type=str, short_name="k",
845
380
                       help="Sign the packages with the specified GnuPG key. "
846
381
                            "Must be specified if you use --dput."),
847
382
                Option("no-build",
848
383
                       help="Just ready the source package and don't "
849
384
                            "actually build it."),
850
385
                Option("watch-ppa", help="Watch the PPA the package was "
851
386
                    "dput to and exit with 0 only if it builds and "
852
387
                    "publishes successfully."),
853
388
                Option("append-version", type=str, help="Append the "
854
389
                        "specified string to the end of the version used "
855
390
                        "in debian/changelog."),
856
391
            ]
857
392
858
393
    takes_args = ["recipe_file", "working_basedir?"]
859
394
860
395
    def run(self, recipe_file, working_basedir=None, manifest=None,
861
396
            if_changed_from=None, package=None, distribution=None,
862
397
            dput=None, key_id=None, no_build=None, watch_ppa=False,
863
398
            append_version=None):
864
399
865
400
        if dput is not None and key_id is None:
866
401
            raise errors.BzrCommandError("You must specify --key-id if you "
867
402
                    "specify --dput.")
868
403
        if watch_ppa:
869
404
            if not dput:
870
405
                raise errors.BzrCommandError(
871
406
                    "cannot watch a ppa without doing dput.")
872
407
            else:
873
408
                # Check we can calculate a PPA url.
874
409
                target_from_dput(dput)
875
410
876
411
        result, base_branch = self._get_prepared_branch_from_recipe(recipe_file,
877
412
            if_changed_from=if_changed_from)
878
413
        if result is not None:
879
414
            return result
880
415
        if working_basedir is None:
881
416
            temp_dir = tempfile.mkdtemp(prefix="bzr-builder-")
882
417
            working_basedir = temp_dir
883
418
        else:
884
419
            temp_dir = None
885
420
            if not os.path.exists(working_basedir):
886
421
                os.makedirs(working_basedir)
887
422
        package_name = self._calculate_package_name(recipe_file, package)
888
423
        working_directory = os.path.join(working_basedir,
889
424
            "%s-%s" % (package_name, self._template_version))
890
425
        try:
891
426
            # we want to use a consistent package_dir always to support
892
427
            # updates in place, but debuild etc want PACKAGE-UPSTREAMVERSION
893
428
            # on disk, so we build_tree with the unsubstituted version number
894
429
            # and do a final rename-to step before calling into debian build
895
430
            # tools. We then rename the working dir back.
896
431
            manifest_path = os.path.join(working_directory, "debian",
897
432
                "bzr-builder.manifest")
898
433
            build_tree(base_branch, working_directory)
899
434
            write_manifest_to_path(manifest_path, base_branch)
900
435
            # Add changelog also substitutes {debupstream}.
901
436
            add_changelog_entry(base_branch, working_directory,
902
437
                distribution=distribution, package=package,
903
438
                append_version=append_version)
904
439
            package_dir = calculate_package_dir(base_branch,
905
440
                    package_name, working_basedir)
906
441
            # working_directory -> package_dir: after this debian stuff works.
907
442
            os.rename(working_directory, package_dir)
908
443
            if no_build:
909
444
                if manifest is not None:
910
445
                    write_manifest_to_path(manifest, base_branch)
911
446
                return 0
912
447
            try:
913
448
                build_source_package(package_dir)
914
449
                if key_id is not None:
915
450
                    sign_source_package(package_dir, key_id)
916
451
                if dput is not None:
917
452
                    dput_source_package(package_dir, dput)
918
453
            finally:
919
454
                # package_dir -> working_directory
920
455
                # FIXME: may fail in error unwind, masking the original exception.
921
456
                os.rename(package_dir, working_directory)
922
457
            # Note that this may write a second manifest.
923
458
            if manifest is not None:
924
459
                write_manifest_to_path(manifest, base_branch)
925
460
        finally:
926
461
            if temp_dir is not None:
927
462
                shutil.rmtree(temp_dir)
928
463
        if watch_ppa:
929
464
            from bzrlib.plugins.builder.ppa import watch
930
465
            target = target_from_dput(dput)
931
466
            if not watch(target, self.package, base_branch.deb_version):
932
467
                return 2
933
468
934
469
    def _calculate_package_name(self, recipe_file, package):
935
470
        """Calculate the directory name that should be used while debuilding."""
936
471
        recipe_name = os.path.basename(recipe_file)
937
472
        if recipe_name.endswith(".recipe"):
938
473
            recipe_name = recipe_name[:-len(".recipe")]
939
474
        return package or recipe_name
940
475
941
476
942
477
def target_from_dput(dput):
943
478
    """Convert a dput specification to a LP API specification.
944
479
945
480
    :param dput: A dput command spec like ppa:team-name.
946
481
    :return: A LP API target like team-name/ppa.
947
482
    """
948
483
    ppa_prefix = 'ppa:'
949
484
    if not dput.startswith(ppa_prefix):
950
485
        raise errors.BzrCommandError('%r does not appear to be a PPA. '
951
486
            'A dput target like \'%suser[/name]\' must be used.'
952
487
            % (dput, ppa_prefix))
953
488
    base, _, suffix = dput[len(ppa_prefix):].partition('/')
954
489
    if not suffix:
955
490
        suffix = 'ppa'
956
491
    return base + '/' + suffix
957
492
958
0
493
959
=== added file 'ppa.py'
960
--- ppa.py	1970-01-01 00:00:00 +0000
961
+++ ppa.py	2010-08-13 01:14:42 +0000
962
@@ -0,0 +1,124 @@
963
1
# ppa support for bzr builder.
964
2
#
965
3
# Copyright: Canonical Ltd. (C) 2009
966
4
#
967
5
# This program is free software: you can redistribute it and/or modify it
968
6
# under the terms of the GNU General Public License version 3, as published
969
7
# by the Free Software Foundation.
970
8
971
9
# This program is distributed in the hope that it will be useful, but
972
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
973
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
974
12
# PURPOSE.  See the GNU General Public License for more details.
975
13
976
14
# You should have received a copy of the GNU General Public License along
977
15
# with this program.  If not, see <http://www.gnu.org/licenses/>.
978
16
979
17
import os
980
18
import time
981
19
982
20
983
21
from launchpadlib.launchpad import (
984
22
    Launchpad,
985
23
    EDGE_SERVICE_ROOT,
986
24
    )
987
25
from launchpadlib.credentials import Credentials
988
26
989
27
from bzrlib import (
990
28
    errors,
991
29
    trace,
992
30
    )
993
31
994
32
995
33
def get_lp():
996
34
    credentials = Credentials()
997
35
    oauth_file = os.path.expanduser('~/.cache/launchpadlib/bzr-builder')
998
36
    if os.path.exists(oauth_file):
999
37
        f = open(oauth_file)
1000
38
        try:
1001
39
            credentials.load(f)
1002
40
        finally:
1003
41
            f.close()
1004
42
        launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT)
1005
43
    else:
1006
44
        launchpad = Launchpad.get_token_and_login('bzr-builder',
1007
45
                EDGE_SERVICE_ROOT)
1008
46
        f = open(oauth_file, 'wb')
1009
47
        try:
1010
48
            launchpad.credentials.save(f)
1011
49
        finally:
1012
50
            f.close()
1013
51
    return launchpad
1014
52
1015
53
1016
54
def watch(owner_name, archive_name, package_name, version):
1017
55
    """Watch a package build.
1018
56
1019
57
    :return: True once the package built and published, or False if it fails
1020
58
        or there is a timeout waiting.
1021
59
    """
1022
60
    version = str(version)
1023
61
    trace.note("Logging into Launchpad")
1024
62
1025
63
    launchpad = get_lp()
1026
64
    owner = launchpad.people[owner_name]
1027
65
    archive = owner.getPPAByName(name=archive_name)
1028
66
    end_states = ['FAILEDTOBUILD', 'FULLYBUILT']
1029
67
    important_arches = ['amd64', 'i386', 'armel']
1030
68
    trace.note("Waiting for version %s of %s to build." % (version, package_name))
1031
69
    start = time.time()
1032
70
    while True:
1033
71
        sourceRecords = list(archive.getPublishedSources(
1034
72
            source_name=package_name, version=version))
1035
73
        if not sourceRecords:
1036
74
            if time.time() - 900 > start:
1037
75
                # Over 15 minutes and no source yet, upload FAIL.
1038
76
                raise errors.BzrCommandError("No source record in %s/%s for "
1039
77
                    "package %s=%s after 15 minutes." % (owner_name,
1040
78
                        archive_name, package_name, version))
1041
79
                return False
1042
80
            trace.note("Source not available yet - waiting.")
1043
81
            time.sleep(60)
1044
82
            continue
1045
83
        pkg = sourceRecords[0]
1046
84
        if pkg.status.lower() not in ('published', 'pending'):
1047
85
            trace.note("Package status: %s" % (pkg.status,))
1048
86
            time.sleep(60)
1049
87
            continue
1050
88
        # FIXME: LP should export this as an attribute.
1051
89
        source_id = pkg.self_link.rsplit('/', 1)[1]
1052
90
        buildSummaries = archive.getBuildSummariesForSourceIds(
1053
91
            source_ids=[source_id])[source_id]
1054
92
        if buildSummaries['status'] in end_states:
1055
93
            break
1056
94
        if buildSummaries['status'] == 'NEEDSBUILD':
1057
95
            # We ignore non-virtual PPA architectures that are sparsely
1058
96
            # supplied with buildds.
1059
97
            missing = []
1060
98
            for build in buildSummaries['builds']:
1061
99
                arch = build['arch_tag']
1062
100
                if arch in important_arches:
1063
101
                    missing.append(arch)
1064
102
            if not missing:
1065
103
                break
1066
104
            extra = ' on ' + ', '.join(missing)
1067
105
        else:
1068
106
            extra = ''
1069
107
        trace.note("%s is still in %s%s" % (pkg.display_name,
1070
108
                    buildSummaries['status'], extra))
1071
109
        time.sleep(60)
1072
110
    trace.note("%s is now %s" % (pkg.display_name, buildSummaries['status']))
1073
111
    result = True
1074
112
    if pkg.status.lower() != 'published':
1075
113
        result = False # should this perhaps keep waiting?
1076
114
    if buildSummaries['status'] != 'FULLYBUILT':
1077
115
        if buildSummaries['status'] == 'NEEDSBUILD':
1078
116
            # We're stopping early cause the important_arches are built.
1079
117
            builds = pkg.getBuilds()
1080
118
            for build in builds:
1081
119
                if build.arch_tag in important_arches:
1082
120
                    if build.buildstate != 'Successfully built':
1083
121
                        result = False
1084
122
        else:
1085
123
            result = False
1086
124
    return result
1087
0
125
1088
=== modified file 'recipe.py'
1089
--- recipe.py	2010-08-13 01:14:42 +0000
1090
+++ recipe.py	2010-08-13 01:14:42 +0000
1091
@@ -22,22 +22,53 @@
1092
22
        bzrdir,
22
        bzrdir,
1093
23
        errors,
23
        errors,
1094
24
        merge,
24
        merge,
1095
25
        revision,
1096
25
        revisionspec,
26
        revisionspec,
1097
26
        tag,
27
        tag,
1098
28
        trace,
1099
27
        transport,
29
        transport,
1100
28
        ui,
1101
29
        urlutils,
30
        urlutils,
1102
30
        )
31
        )
1103
31
32
1104
32
33
1105
34
try:
1106
35
    from debian import changelog
1107
36
except ImportError:
1108
37
    from debian_bundle import changelog
1109
38
1110
39
1111
33
def subprocess_setup():
40
def subprocess_setup():
1112
34
    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
41
    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
1113
35
42
1114
36
43
1115
37
MERGE_INSTRUCTION = "merge"
44
MERGE_INSTRUCTION = "merge"
1116
45
NEST_PART_INSTRUCTION = "nest-part"
1117
38
NEST_INSTRUCTION = "nest"
46
NEST_INSTRUCTION = "nest"
1118
39
RUN_INSTRUCTION = "run"
47
RUN_INSTRUCTION = "run"
1119
40
48
1120
49
TIME_VAR = "{time}"
1121
50
DATE_VAR = "{date}"
1122
51
REVNO_VAR = "{revno}"
1123
52
REVNO_PARAM_VAR = "{revno:%s}"
1124
53
DEBUPSTREAM_VAR = "{debupstream}"
1125
54
1126
55
ok_to_preserve = [DEBUPSTREAM_VAR]
1127
56
# The variables that don't require substitution in their name
1128
57
simple_vars = [TIME_VAR, DATE_VAR, REVNO_VAR, DEBUPSTREAM_VAR]
1129
58
1130
59
1131
60
def check_expanded_deb_version(base_branch):
1132
61
    checked_version = base_branch.deb_version
1133
62
    for token in ok_to_preserve:
1134
63
        checked_version = checked_version.replace(token, "")
1135
64
    if "{" in checked_version:
1136
65
        available_tokens = simple_vars
1137
66
        for name in base_branch.list_branch_names():
1138
67
            available_tokens.append(REVNO_PARAM_VAR % name)
1139
68
        raise errors.BzrCommandError("deb-version not fully "
1140
69
                "expanded: %s. Valid substitutions are: %s"
1141
70
                % (base_branch.deb_version, available_tokens))
1142
71
1143
41
72
1144
42
class CommandFailedError(errors.BzrError):
73
class CommandFailedError(errors.BzrError):
1145
43
74
1146
@@ -113,10 +144,10 @@
1147
113
        # We do a "pull"
144
        # We do a "pull"
1148
114
        if tree_to is not None:
145
        if tree_to is not None:
1149
115
            # FIXME: should these pulls overwrite?
146
            # FIXME: should these pulls overwrite?
1151
116
            result = tree_to.pull(br_from, stop_revision=revision_id,
147
            tree_to.pull(br_from, stop_revision=revision_id,
1152
117
                    possible_transports=possible_transports)
148
                    possible_transports=possible_transports)
1153
118
        else:
149
        else:
1155
119
            result = br_to.pull(br_from, stop_revision=revision_id,
150
            br_to.pull(br_from, stop_revision=revision_id,
1156
120
                    possible_transports=possible_transports)
151
                    possible_transports=possible_transports)
1157
121
            tree_to = br_to.bzrdir.create_workingtree()
152
            tree_to = br_to.bzrdir.create_workingtree()
1158
122
            # Ugh, we have to assume that the caller replaces their reference
153
            # Ugh, we have to assume that the caller replaces their reference
1159
@@ -146,7 +177,7 @@
1160
146
    return tree_to, br_to
177
    return tree_to, br_to
1161
147
178
1162
148
179
1164
149
def merge_branch(child_branch, tree_to, br_to):
180
def merge_branch(child_branch, tree_to, br_to, possible_transports=None):
1165
150
    """Merge the branch specified by child_branch.
181
    """Merge the branch specified by child_branch.
1166
151
182
1167
152
    :param child_branch: the RecipeBranch to retrieve the branch and revision to
183
    :param child_branch: the RecipeBranch to retrieve the branch and revision to
1168
@@ -154,82 +185,129 @@
1169
154
    :param tree_to: the WorkingTree to merge in to.
185
    :param tree_to: the WorkingTree to merge in to.
1170
155
    :param br_to: the Branch to merge in to.
186
    :param br_to: the Branch to merge in to.
1171
156
    """
187
    """
1172
188
    if child_branch.branch is None:
1173
189
        child_branch.branch = branch.Branch.open(child_branch.url,
1174
190
                possible_transports=possible_transports)
1175
191
    child_branch.branch.lock_read()
1176
192
    try:
1177
193
        tag._merge_tags_if_possible(child_branch.branch, br_to)
1178
194
        if child_branch.revspec is not None:
1179
195
            merge_revspec = revisionspec.RevisionSpec.from_string(
1180
196
                    child_branch.revspec)
1181
197
            try:
1182
198
                merge_revid = merge_revspec.as_revision_id(
1183
199
                    child_branch.branch)
1184
200
            except errors.InvalidRevisionSpec, e:
1185
201
                # Give the user a hint if they didn't mean to speciy
1186
202
                # a revspec.
1187
203
                e.extra = (". Did you not mean to specify a revspec "
1188
204
                    "at the end of the merge line?")
1189
205
                raise e
1190
206
        else:
1191
207
            merge_revid = child_branch.branch.last_revision()
1192
208
        child_branch.revid = merge_revid
1193
209
        merger = merge.Merger.from_revision_ids(None, tree_to, merge_revid,
1194
210
                other_branch=child_branch.branch, tree_branch=br_to)
1195
211
        merger.merge_type = merge.Merge3Merger
1196
212
        if (merger.base_rev_id == merger.other_rev_id and
1197
213
                merger.other_rev_id is not None):
1198
214
            # Nothing to do.
1199
215
            return
1200
216
        conflict_count = merger.do_merge()
1201
217
        merger.set_pending()
1202
218
        if conflict_count:
1203
219
            # FIXME: better reporting
1204
220
            raise errors.BzrCommandError("Conflicts from merge")
1205
221
        tree_to.commit("Merge %s" %
1206
222
                urlutils.unescape_for_display(
1207
223
                    child_branch.url, 'utf-8'))
1208
224
    finally:
1209
225
        child_branch.branch.unlock()
1210
226
1211
227
1212
228
def nest_part_branch(op, child_branch, tree_to, br_to, subpath,
1213
229
        target_subdir=None):
1214
230
    """Merge the branch subdirectory specified by child_branch.
1215
231
1216
232
    :param child_branch: the RecipeBranch to retrieve the branch and revision to
1217
233
            merge from.
1218
234
    :param tree_to: the WorkingTree to merge in to.
1219
235
    :param br_to: the Branch to merge in to.
1220
236
    :param subpath: only merge files from branch that are from this path.
1221
237
        e.g. subpath='/debian' will only merge changes from that directory.
1222
238
    :param target_subdir: (optional) directory in target to merge that
1223
239
        subpath into.  Defaults to basename of subpath.
1224
240
    """
1225
157
    merge_from = branch.Branch.open(child_branch.url)
241
    merge_from = branch.Branch.open(child_branch.url)
1226
158
    merge_from.lock_read()
242
    merge_from.lock_read()
1264
159
    try:
243
    op.add_cleanup(merge_from.unlock)
1265
160
        pb = ui.ui_factory.nested_progress_bar()
244
    if child_branch.revspec is not None:
1266
161
        try:
245
        merge_revspec = revisionspec.RevisionSpec.from_string(
1267
162
            tag._merge_tags_if_possible(merge_from, br_to)
246
                child_branch.revspec)
1268
163
            if child_branch.revspec is not None:
247
        merge_revid = merge_revspec.as_revision_id(merge_from)
1269
164
                merge_revspec = revisionspec.RevisionSpec.from_string(
248
    else:
1270
165
                        child_branch.revspec)
249
        merge_revid = merge_from.last_revision()
1271
166
                merge_revid = merge_revspec.as_revision_id(merge_from)
250
    child_branch.revid = merge_revid
1272
167
            else:
251
    other_tree = merge_from.basis_tree()
1273
168
                merge_revid = merge_from.last_revision()
252
    other_tree.lock_read()
1274
169
            child_branch.revid = merge_revid
253
    op.add_cleanup(other_tree.unlock)
1275
170
            merger = merge.Merger.from_revision_ids(pb, tree_to, merge_revid,
254
    if target_subdir is None:
1276
171
                    other_branch=merge_from, tree_branch=br_to)
255
        target_subdir = os.path.basename(subpath)
1277
172
            merger.merge_type = merge.Merge3Merger
256
    merger = merge.MergeIntoMerger(this_tree=tree_to, other_tree=other_tree,
1278
173
            if (merger.base_rev_id == merger.other_rev_id and
257
        other_branch=merge_from, target_subdir=target_subdir,
1279
174
                    merger.other_rev_id is not None):
258
        source_subpath=subpath, other_rev_id=merge_revid)
1280
175
                # Nothing to do.
259
    merger.set_base_revision(revision.NULL_REVISION, merge_from)
1281
176
                return
260
    conflict_count = merger.do_merge()
1282
177
            conflict_count = merger.do_merge()
261
    merger.set_pending()
1283
178
            merger.set_pending()
262
    if conflict_count:
1284
179
            if conflict_count:
263
        # FIXME: better reporting
1285
180
                # FIXME: better reporting
264
        raise errors.BzrCommandError("Conflicts from merge")
1286
181
                raise errors.BzrCommandError("Conflicts from merge")
265
    tree_to.commit("Merge %s of %s" %
1287
182
            tree_to.commit("Merge %s" %
266
        (subpath, urlutils.unescape_for_display(child_branch.url, 'utf-8')))
1288
183
                    urlutils.unescape_for_display(
267
1289
184
                        child_branch.url, 'utf-8'))
268
1290
185
        finally:
269
def update_branch(base_branch, tree_to, br_to, to_transport,
1291
186
            pb.finished()
270
        possible_transports=None):
1292
187
    finally:
271
    if base_branch.branch is None:
1293
188
        merge_from.unlock()
272
        base_branch.branch = branch.Branch.open(base_branch.url,
1294
189
273
                possible_transports=possible_transports)
1295
190
274
    base_branch.branch.lock_read()
1259
191
def update_branch(base_branch, tree_to, br_to, to_transport):
1260
192
    from_location = base_branch.url
1261
193
    accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1262
194
                        from_location)
1263
195
    br_from.lock_read()
1296
196
    try:
275
    try:
1297
197
        if base_branch.revspec is not None:
276
        if base_branch.revspec is not None:
1298
198
            revspec = revisionspec.RevisionSpec.from_string(
277
            revspec = revisionspec.RevisionSpec.from_string(
1299
199
                    base_branch.revspec)
278
                    base_branch.revspec)
1301
200
            revision_id = revspec.as_revision_id(br_from)
279
            revision_id = revspec.as_revision_id(base_branch.branch)
1302
201
        else:
280
        else:
1304
202
            revision_id = br_from.last_revision()
281
            revision_id = base_branch.branch.last_revision()
1305
203
        base_branch.revid = revision_id
282
        base_branch.revid = revision_id
1307
204
        tree_to, br_to = pull_or_branch(tree_to, br_to, br_from,
283
        tree_to, br_to = pull_or_branch(tree_to, br_to, base_branch.branch,
1308
205
                to_transport, revision_id,
284
                to_transport, revision_id,
1311
206
                accelerator_tree=accelerator_tree,
285
                possible_transports=possible_transports)
1310
207
                possible_transports=[to_transport])
1312
208
    finally:
286
    finally:
1314
209
        br_from.unlock()
287
        base_branch.branch.unlock()
1315
210
    return tree_to, br_to
288
    return tree_to, br_to
1316
211
289
1317
212
290
1318
213
def _resolve_revisions_recurse(new_branch, substitute_revno,
291
def _resolve_revisions_recurse(new_branch, substitute_revno,
1319
214
        if_changed_from=None):
292
        if_changed_from=None):
1320
215
    changed = False
293
    changed = False
1323
216
    br_from = branch.Branch.open(new_branch.url)
294
    new_branch.branch = branch.Branch.open(new_branch.url)
1324
217
    br_from.lock_read()
295
    new_branch.branch.lock_read()
1325
218
    try:
296
    try:
1326
219
        if new_branch.revspec is not None:
297
        if new_branch.revspec is not None:
1327
220
            revspec = revisionspec.RevisionSpec.from_string(
298
            revspec = revisionspec.RevisionSpec.from_string(
1328
221
                    new_branch.revspec)
299
                    new_branch.revspec)
1330
222
            revision_id = revspec.as_revision_id(br_from)
300
            revision_id = revspec.as_revision_id(new_branch.branch)
1331
223
        else:
301
        else:
1333
224
            revision_id = br_from.last_revision()
302
            revision_id = new_branch.branch.last_revision()
1334
225
        new_branch.revid = revision_id
303
        new_branch.revid = revision_id
1335
226
        def get_revno():
304
        def get_revno():
1336
227
            try:
305
            try:
1338
228
                revno = br_from.revision_id_to_revno(revision_id)
306
                revno = new_branch.branch.revision_id_to_revno(revision_id)
1339
229
                return str(revno)
307
                return str(revno)
1340
230
            except errors.NoSuchRevision:
308
            except errors.NoSuchRevision:
1341
231
                # We need to load and use the full revno map after all
309
                # We need to load and use the full revno map after all
1343
232
                result = br_from.get_revision_id_to_revno_map().get(
310
                result = new_branch.branch.get_revision_id_to_revno_map().get(
1344
233
                        revision_id)
311
                        revision_id)
1345
234
            if result is None:
312
            if result is None:
1346
235
                return result
313
                return result
1347
@@ -242,14 +320,13 @@
1348
242
                changed_revspec = revisionspec.RevisionSpec.from_string(
320
                changed_revspec = revisionspec.RevisionSpec.from_string(
1349
243
                        if_changed_from.revspec)
321
                        if_changed_from.revspec)
1350
244
                changed_revision_id = changed_revspec.as_revision_id(
322
                changed_revision_id = changed_revspec.as_revision_id(
1352
245
                        br_from)
323
                        new_branch.branch)
1353
246
            else:
324
            else:
1355
247
                changed_revision_id = br_from.last_revision()
325
                changed_revision_id = new_branch.branch.last_revision()
1356
248
            if revision_id != changed_revision_id:
326
            if revision_id != changed_revision_id:
1357
249
                changed = True
327
                changed = True
1358
250
        for index, instruction in enumerate(new_branch.child_branches):
328
        for index, instruction in enumerate(new_branch.child_branches):
1359
251
            child_branch = instruction.recipe_branch
329
            child_branch = instruction.recipe_branch
1360
252
            nest_location = instruction.nest_path
1361
253
            if_changed_child = None
330
            if_changed_child = None
1362
254
            if if_changed_from is not None:
331
            if if_changed_from is not None:
1363
255
                if_changed_child = if_changed_from.child_branches[index].recipe_branch
332
                if_changed_child = if_changed_from.child_branches[index].recipe_branch
1364
@@ -261,7 +338,7 @@
1365
261
                    changed = child_changed
338
                    changed = child_changed
1366
262
        return changed
339
        return changed
1367
263
    finally:
340
    finally:
1369
264
        br_from.unlock()
341
        new_branch.branch.unlock()
1370
265
342
1371
266
343
1372
267
def resolve_revisions(base_branch, if_changed_from=None):
344
def resolve_revisions(base_branch, if_changed_from=None):
1373
@@ -289,30 +366,20 @@
1374
289
            if_changed_from=if_changed_from_revisions)
366
            if_changed_from=if_changed_from_revisions)
1375
290
    if not changed:
367
    if not changed:
1376
291
        changed = changed_revisions
368
        changed = changed_revisions
1384
292
    ok_to_preserve = ["{debupstream}"]
369
    check_expanded_deb_version(base_branch)
1378
293
    checked_version = base_branch.deb_version
1379
294
    for token in ok_to_preserve:
1380
295
        checked_version = checked_version.replace(token, "")
1381
296
    if "{" in checked_version:
1382
297
        raise errors.BzrCommandError("deb-version not fully "
1383
298
                "expanded: %s" % base_branch.deb_version)
1385
299
    if if_changed_from is not None and not changed:
370
    if if_changed_from is not None and not changed:
1386
300
        return False
371
        return False
1387
301
    return True
372
    return True
1388
302
373
1389
303
374
1402
304
def build_tree(base_branch, target_path):
375
def _build_inner_tree(base_branch, target_path, possible_transports=None):
1403
305
    """Build the RecipeBranch at a path.
376
    revision_of = ""
1404
306
377
    if base_branch.revspec is not None:
1405
307
    Follow the instructions embodied in RecipeBranch and build a tree
378
        revision_of = "revision '%s' of " % base_branch.revspec
1406
308
    based on them rooted at target_path. If target_path exists and
379
    trace.note("Retrieving %s'%s' to put at '%s'."
1407
309
    is the root of the branch then the branch will be updated based on
380
        % (revision_of, base_branch.url, target_path))
1408
310
    what the RecipeBranch requires.
381
    to_transport = transport.get_transport(target_path,
1409
311
382
            possible_transports=possible_transports)
1398
312
    :param base_branch: a RecipeBranch to build.
1399
313
    :param target_path: the path to the base of the desired output.
1400
314
    """
1401
315
    to_transport = transport.get_transport(target_path)
1410
316
    try:
383
    try:
1411
317
        tree_to, br_to = bzrdir.BzrDir.open_tree_or_branch(target_path)
384
        tree_to, br_to = bzrdir.BzrDir.open_tree_or_branch(target_path)
1412
318
        # Should we commit any changes in the tree here? If we don't
385
        # Should we commit any changes in the tree here? If we don't
1413
@@ -327,7 +394,7 @@
1414
327
            br_to.lock_write()
394
            br_to.lock_write()
1415
328
        try:
395
        try:
1416
329
            tree_to, br_to = update_branch(base_branch, tree_to, br_to,
396
            tree_to, br_to = update_branch(base_branch, tree_to, br_to,
1418
330
                    to_transport)
397
                    to_transport, possible_transports=possible_transports)
1419
331
            for instruction in base_branch.child_branches:
398
            for instruction in base_branch.child_branches:
1420
332
                instruction.apply(target_path, tree_to, br_to)
399
                instruction.apply(target_path, tree_to, br_to)
1421
333
        finally:
400
        finally:
1422
@@ -339,49 +406,25 @@
1423
339
            tree_to.unlock()
406
            tree_to.unlock()
1424
340
407
1425
341
408
1464
342
def _add_child_branches_to_manifest(child_branches, indent_level):
409
def build_tree(base_branch, target_path, possible_transports=None):
1465
343
    manifest = ""
410
    """Build the RecipeBranch at a path.
1466
344
    for instruction in child_branches:
411
1467
345
        child_branch = instruction.recipe_branch
412
    Follow the instructions embodied in RecipeBranch and build a tree
1468
346
        nest_location = instruction.nest_path
413
    based on them rooted at target_path. If target_path exists and
1469
347
        if child_branch is None:
414
    is the root of the branch then the branch will be updated based on
1470
348
            manifest += "%s%s %s\n" % ("  " * indent_level, RUN_INSTRUCTION,
415
    what the RecipeBranch requires.
1471
349
                    nest_location)
416
1472
350
        else:
417
    :param base_branch: a RecipeBranch to build.
1473
351
            assert child_branch.revid is not None, "Branch hasn't been built"
418
    :param target_path: the path to the base of the desired output.
1474
352
            if nest_location is not None:
419
    """
1475
353
                manifest += "%s%s %s %s %s revid:%s\n" % \
420
    trace.note("Building tree.")
1476
354
                             ("  " * indent_level, NEST_INSTRUCTION,
421
    _build_inner_tree(base_branch, target_path,
1477
355
                              child_branch.name,
422
            possible_transports=possible_transports)
1440
356
                              child_branch.url, nest_location,
1441
357
                              child_branch.revid)
1442
358
                manifest += _add_child_branches_to_manifest(
1443
359
                        child_branch.child_branches, indent_level+1)
1444
360
            else:
1445
361
                manifest += "%s%s %s %s revid:%s\n" % \
1446
362
                             ("  " * indent_level, MERGE_INSTRUCTION,
1447
363
                              child_branch.name,
1448
364
                              child_branch.url, child_branch.revid)
1449
365
    return manifest
1450
366
1451
367
1452
368
def build_manifest(base_branch):
1453
369
    manifest = "# bzr-builder format %s deb-version " % str(base_branch.format)
1454
370
    # TODO: should we store the expanded version that was used?
1455
371
    manifest += "%s\n" % (base_branch.deb_version,)
1456
372
    assert base_branch.revid is not None, "Branch hasn't been built"
1457
373
    manifest += "%s revid:%s\n" % (base_branch.url, base_branch.revid)
1458
374
    manifest += _add_child_branches_to_manifest(base_branch.child_branches, 0)
1459
375
    # Sanity check.
1460
376
    # TODO: write a function that compares the result of this parse with
1461
377
    # the branch that we built it from.
1462
378
    RecipeParser(manifest).parse()
1463
379
    return manifest
1478
380
423
1479
381
424
1480
382
class ChildBranch(object):
425
class ChildBranch(object):
1481
383
    """A child branch in a recipe.
426
    """A child branch in a recipe.
1483
384
    
427
1484
385
    If the nest path is not None it is the path relative to the recipe branch
428
    If the nest path is not None it is the path relative to the recipe branch
1485
386
    where the child branch should be placed.  If it is None then the child
429
    where the child branch should be placed.  If it is None then the child
1486
387
    branch should be merged instead of nested.
430
    branch should be merged instead of nested.
1487
@@ -390,8 +433,8 @@
1488
390
    def __init__(self, recipe_branch, nest_path=None):
433
    def __init__(self, recipe_branch, nest_path=None):
1489
391
        self.recipe_branch = recipe_branch
434
        self.recipe_branch = recipe_branch
1490
392
        self.nest_path = nest_path
435
        self.nest_path = nest_path
1493
393
        
436
1494
394
    def apply(self, target_path, tree_to, br_to):
437
    def apply(self, target_path, tree_to, br_to, possible_transports=None):
1495
395
        raise NotImplementedError(self.apply)
438
        raise NotImplementedError(self.apply)
1496
396
439
1497
397
    def as_tuple(self):
440
    def as_tuple(self):
1498
@@ -400,8 +443,9 @@
1499
400
443
1500
401
class CommandInstruction(ChildBranch):
444
class CommandInstruction(ChildBranch):
1501
402
445
1503
403
    def apply(self, target_path, tree_to, br_to):
446
    def apply(self, target_path, tree_to, br_to, possible_transports=None):
1504
404
        # it's a command
447
        # it's a command
1505
448
        trace.note("Running '%s' in '%s'." % (self.nest_path, target_path))
1506
405
        proc = subprocess.Popen(self.nest_path, cwd=target_path,
449
        proc = subprocess.Popen(self.nest_path, cwd=target_path,
1507
406
            preexec_fn=subprocess_setup, shell=True, stdin=subprocess.PIPE)
450
            preexec_fn=subprocess_setup, shell=True, stdin=subprocess.PIPE)
1508
407
        proc.communicate()
451
        proc.communicate()
1509
@@ -411,16 +455,36 @@
1510
411
455
1511
412
class MergeInstruction(ChildBranch):
456
class MergeInstruction(ChildBranch):
1512
413
457
1513
458
    def apply(self, target_path, tree_to, br_to, possible_transports=None):
1514
459
        revision_of = ""
1515
460
        if self.recipe_branch.revspec is not None:
1516
461
            revision_of = "revision '%s' of " % self.recipe_branch.revspec
1517
462
        trace.note("Merging %s'%s' in to '%s'."
1518
463
                % (revision_of, self.recipe_branch.url, target_path))
1519
464
        merge_branch(self.recipe_branch, tree_to, br_to,
1520
465
                possible_transports=possible_transports)
1521
466
1522
467
1523
468
class NestPartInstruction(ChildBranch):
1524
469
1525
470
    def __init__(self, recipe_branch, subpath, target_subdir):
1526
471
        ChildBranch.__init__(self, recipe_branch)
1527
472
        self.subpath = subpath
1528
473
        self.target_subdir = target_subdir
1529
474
1530
414
    def apply(self, target_path, tree_to, br_to):
475
    def apply(self, target_path, tree_to, br_to):
1532
415
        merge_branch(self.recipe_branch, tree_to, br_to)
476
        from bzrlib.cleanup import OperationWithCleanups
1533
477
        op = OperationWithCleanups(nest_part_branch)
1534
478
        op.run(self.recipe_branch, tree_to, br_to, self.subpath,
1535
479
            self.target_subdir)
1536
416
480
1537
417
481
1538
418
class NestInstruction(ChildBranch):
482
class NestInstruction(ChildBranch):
1539
419
483
1544
420
    def apply(self, target_path, tree_to, br_to):
484
    def apply(self, target_path, tree_to, br_to, possible_transports=None):
1545
421
        # FIXME: pass possible_transports around
485
        _build_inner_tree(self.recipe_branch,
1546
422
        build_tree(self.recipe_branch,
486
            target_path=os.path.join(target_path, self.nest_path),
1547
423
            target_path=os.path.join(target_path, self.nest_path))
487
            possible_transports=possible_transports)
1548
424
488
1549
425
489
1550
426
class RecipeBranch(object):
490
class RecipeBranch(object):
1551
@@ -430,9 +494,12 @@
1552
430
    root branch), and optionally child branches that are either merged
494
    root branch), and optionally child branches that are either merged
1553
431
    or nested.
495
    or nested.
1554
432
496
1556
433
    The child_branches attribute is a list of tuples of ChildBranch objects. 
497
    The child_branches attribute is a list of tuples of ChildBranch objects.
1557
434
    The revid attribute records the revid that the url and revspec resolved
498
    The revid attribute records the revid that the url and revspec resolved
1558
435
    to when the RecipeBranch was built, or None if it has not been built.
499
    to when the RecipeBranch was built, or None if it has not been built.
1559
500
1560
501
    :ivar revid: after this recipe branch has been built this is set to the
1561
502
        revision ID that was merged/nested from the branch at self.url.
1562
436
    """
503
    """
1563
437
504
1564
438
    def __init__(self, name, url, revspec=None):
505
    def __init__(self, name, url, revspec=None):
1565
@@ -448,6 +515,7 @@
1566
448
        self.revspec = revspec
515
        self.revspec = revspec
1567
449
        self.child_branches = []
516
        self.child_branches = []
1568
450
        self.revid = None
517
        self.revid = None
1569
518
        self.branch = None
1570
451
519
1571
452
    def merge_branch(self, branch):
520
    def merge_branch(self, branch):
1572
453
        """Merge a child branch in to this one.
521
        """Merge a child branch in to this one.
1573
@@ -456,6 +524,18 @@
1574
456
        """
524
        """
1575
457
        self.child_branches.append(MergeInstruction(branch))
525
        self.child_branches.append(MergeInstruction(branch))
1576
458
526
1577
527
    def nest_part_branch(self, branch, subpath=None, target_subdir=None):
1578
528
        """Merge subdir of a child branch into this one.
1579
529
1580
530
        :param branch: the RecipeBranch to merge.
1581
531
        :param subpath: only merge files from branch that are from this path.
1582
532
            e.g. subpath='/debian' will only merge changes from that directory.
1583
533
        :param target_subdir: (optional) directory in target to merge that
1584
534
            subpath into.  Defaults to basename of subpath.
1585
535
        """
1586
536
        self.child_branches.append(
1587
537
            NestPartInstruction(branch, subpath, target_subdir))
1588
538
1589
459
    def nest_branch(self, location, branch):
539
    def nest_branch(self, location, branch):
1590
460
        """Nest a child branch in to this one.
540
        """Nest a child branch in to this one.
1591
461
541
1592
@@ -492,10 +572,32 @@
1593
492
            if ((child_branch is None and other_child_branch is not None)
572
            if ((child_branch is None and other_child_branch is not None)
1594
493
                    or (child_branch is not None and other_child_branch is None)):
573
                    or (child_branch is not None and other_child_branch is None)):
1595
494
                return True
574
                return True
1597
495
            if child_branch.different_shape_to(other_child_branch):
575
            # if child_branch is None then other_child_branch must be
1598
576
            # None too, meaning that they are both run instructions,
1599
577
            # we would compare their nest locations (commands), but
1600
578
            # that has already been done, so just guard
1601
579
            if (child_branch is not None
1602
580
                    and child_branch.different_shape_to(other_child_branch)):
1603
496
                return True
581
                return True
1604
497
        return False
582
        return False
1605
498
583
1606
584
    def _list_child_names(self):
1607
585
        child_names = []
1608
586
        for instruction in self.child_branches:
1609
587
            child_branch = instruction.recipe_branch
1610
588
            if child_branch is None:
1611
589
                continue
1612
590
            child_names += child_branch.list_branch_names()
1613
591
        return child_names
1614
592
1615
593
    def list_branch_names(self):
1616
594
        """List all of the branch names under this one.
1617
595
1618
596
        :return: a list of the branch names.
1619
597
        :rtype: list(str)
1620
598
        """
1621
599
        return [self.name] + self._list_child_names()
1622
600
1623
499
601
1624
500
class BaseRecipeBranch(RecipeBranch):
602
class BaseRecipeBranch(RecipeBranch):
1625
501
    """The RecipeBranch that is at the root of a recipe."""
603
    """The RecipeBranch that is at the root of a recipe."""
1626
@@ -521,9 +623,9 @@
1627
521
            needed.
623
            needed.
1628
522
        """
624
        """
1629
523
        if branch_name is None:
625
        if branch_name is None:
1631
524
            subst_string = "{revno}"
626
            subst_string = REVNO_VAR
1632
525
        else:
627
        else:
1634
526
            subst_string = "{revno:%s}" % branch_name
628
            subst_string = REVNO_PARAM_VAR % branch_name
1635
527
        if subst_string in self.deb_version:
629
        if subst_string in self.deb_version:
1636
528
            revno = get_revno_cb()
630
            revno = get_revno_cb()
1637
529
            if revno is None:
631
            if revno is None:
1638
@@ -537,9 +639,75 @@
1639
537
639
1640
538
        :param time: a datetime.datetime with the desired time.
640
        :param time: a datetime.datetime with the desired time.
1641
539
        """
641
        """
1644
540
        if "{time}" in self.deb_version:
642
        if TIME_VAR in self.deb_version:
1645
541
            self.deb_version = self.deb_version.replace("{time}",
643
            self.deb_version = self.deb_version.replace(TIME_VAR,
1646
542
                    time.strftime("%Y%m%d%H%M"))
644
                    time.strftime("%Y%m%d%H%M"))
1647
645
        if DATE_VAR in self.deb_version:
1648
646
            self.deb_version = self.deb_version.replace(DATE_VAR,
1649
647
                    time.strftime("%Y%m%d"))
1650
648
1651
649
    def substitute_debupstream(self, version):
1652
650
        """Substitute {debupstream} in to deb_version if needed.
1653
651
1654
652
        :param version: the Version object to take the upstream version
1655
653
            from.
1656
654
        """
1657
655
        if DEBUPSTREAM_VAR in self.deb_version:
1658
656
            # Should we include the epoch?
1659
657
            self.deb_version = self.deb_version.replace(DEBUPSTREAM_VAR,
1660
658
                    version.upstream_version)
1661
659
1662
660
    def _add_child_branches_to_manifest(self, child_branches, indent_level):
1663
661
        manifest = ""
1664
662
        for instruction in child_branches:
1665
663
            child_branch = instruction.recipe_branch
1666
664
            nest_location = instruction.nest_path
1667
665
            if child_branch is None:
1668
666
                manifest += "%s%s %s\n" % ("  " * indent_level, RUN_INSTRUCTION,
1669
667
                        nest_location)
1670
668
            else:
1671
669
                if child_branch.revid is not None:
1672
670
                    revid_part = " revid:%s" % child_branch.revid
1673
671
                elif child_branch.revspec is not None:
1674
672
                    revid_part = " %s" % child_branch.revspec
1675
673
                else:
1676
674
                    revid_part = ""
1677
675
                if nest_location is not None:
1678
676
                    manifest += "%s%s %s %s %s%s\n" % \
1679
677
                                 ("  " * indent_level, NEST_INSTRUCTION,
1680
678
                                  child_branch.name,
1681
679
                                  child_branch.url, nest_location,
1682
680
                                  revid_part)
1683
681
                    manifest += self._add_child_branches_to_manifest(
1684
682
                            child_branch.child_branches, indent_level+1)
1685
683
                else:
1686
684
                    manifest += "%s%s %s %s%s\n" % \
1687
685
                                 ("  " * indent_level, MERGE_INSTRUCTION,
1688
686
                                  child_branch.name,
1689
687
                                  child_branch.url, revid_part)
1690
688
        return manifest
1691
689
1692
690
1693
691
    def __str__(self):
1694
692
        manifest = "# bzr-builder format %s deb-version " % str(self.format)
1695
693
        # TODO: should we store the expanded version that was used?
1696
694
        manifest += "%s\n" % (self.deb_version,)
1697
695
        if self.revid is not None:
1698
696
            manifest += "%s revid:%s\n" % (self.url, self.revid)
1699
697
        elif self.revspec is not None:
1700
698
            manifest += "%s %s\n" % (self.url, self.revspec)
1701
699
        else:
1702
700
            manifest += "%s\n" % (self.url,)
1703
701
        manifest += self._add_child_branches_to_manifest(self.child_branches,
1704
702
                0)
1705
703
        # Sanity check.
1706
704
        # TODO: write a function that compares the result of this parse with
1707
705
        # the branch that we built it from.
1708
706
        RecipeParser(manifest).parse()
1709
707
        return manifest
1710
708
1711
709
    def list_branch_names(self):
1712
710
        return self._list_child_names()
1713
543
711
1714
544
712
1715
545
class RecipeParseError(errors.BzrError):
713
class RecipeParseError(errors.BzrError):
1716
@@ -550,6 +718,13 @@
1717
550
                problem=problem)
718
                problem=problem)
1718
551
719
1719
552
720
1720
721
class ForbiddenInstructionError(RecipeParseError):
1721
722
1722
723
    def __init__(self, filename, line, char, problem, instruction_name=None):
1723
724
        RecipeParseError.__init__(self, filename, line, char, problem)
1724
725
        self.instruction_name = instruction_name
1725
726
1726
727
1727
553
class RecipeParser(object):
728
class RecipeParser(object):
1728
554
    """Parse a recipe.
729
    """Parse a recipe.
1729
555
730
1730
@@ -560,7 +735,7 @@
1731
560
    eol_char = "\n"
735
    eol_char = "\n"
1732
561
    digit_chars = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")
736
    digit_chars = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")
1733
562
737
1735
563
    NEWEST_VERSION = 0.2
738
    NEWEST_VERSION = 0.3
1736
564
739
1737
565
    def __init__(self, f, filename=None):
740
    def __init__(self, f, filename=None):
1738
566
        """Create a RecipeParser.
741
        """Create a RecipeParser.
1739
@@ -578,9 +753,12 @@
1740
578
        if filename is None:
753
        if filename is None:
1741
579
            self.filename = "recipe"
754
            self.filename = "recipe"
1742
580
755
1744
581
    def parse(self):
756
    def parse(self, forbidden_instructions=None):
1745
582
        """Parse the recipe.
757
        """Parse the recipe.
1746
583
758
1747
759
        :param forbidden_instructions: a list of instructions that you
1748
760
            don't want to allow. Defaults to None allowing them all.
1749
761
        :type forbidden_instructions: list(str) or None
1750
584
        :return: a RecipeBranch representing the recipe.
762
        :return: a RecipeBranch representing the recipe.
1751
585
        """
763
        """
1752
586
        self.lines = self.text.split("\n")
764
        self.lines = self.text.split("\n")
1753
@@ -588,12 +766,21 @@
1754
588
        self.line_index = 0
766
        self.line_index = 0
1755
589
        self.current_line = self.lines[self.line_index]
767
        self.current_line = self.lines[self.line_index]
1756
590
        self.current_indent_level = 0
768
        self.current_indent_level = 0
1757
769
        self.seen_nicks = set()
1758
770
        self.seen_paths = {".": 1}
1759
591
        (version, deb_version) = self.parse_header()
771
        (version, deb_version) = self.parse_header()
1760
592
        self.version = version
772
        self.version = version
1761
593
        last_instruction = None
773
        last_instruction = None
1762
594
        active_branches = []
774
        active_branches = []
1763
595
        last_branch = None
775
        last_branch = None
1764
596
        while self.line_index < len(self.lines):
776
        while self.line_index < len(self.lines):
1765
777
            if self.is_blankline():
1766
778
                self.new_line()
1767
779
                continue
1768
780
            comment = self.parse_comment_line()
1769
781
            if comment is not None:
1770
782
                self.new_line()
1771
783
                continue
1772
597
            old_indent_level = self.parse_indent()
784
            old_indent_level = self.parse_indent()
1773
598
            if old_indent_level is not None:
785
            if old_indent_level is not None:
1774
599
                if (old_indent_level < self.current_indent_level
786
                if (old_indent_level < self.current_indent_level
1775
@@ -605,10 +792,6 @@
1776
605
                else:
792
                else:
1777
606
                    unindent = self.current_indent_level - old_indent_level
793
                    unindent = self.current_indent_level - old_indent_level
1778
607
                    active_branches = active_branches[:unindent]
794
                    active_branches = active_branches[:unindent]
1779
608
            comment = self.parse_comment_line()
1780
609
            if comment is not None:
1781
610
                self.new_line()
1782
611
                continue
1783
612
            if last_instruction is None:
795
            if last_instruction is None:
1784
613
                url = self.take_to_whitespace("branch to start from")
796
                url = self.take_to_whitespace("branch to start from")
1785
614
                revspec = self.parse_optional_revspec()
797
                revspec = self.parse_optional_revspec()
1786
@@ -618,7 +801,8 @@
1787
618
                active_branches = [last_branch]
801
                active_branches = [last_branch]
1788
619
                last_instruction = ""
802
                last_instruction = ""
1789
620
            else:
803
            else:
1791
621
                instruction = self.parse_instruction()
804
                instruction = self.parse_instruction(
1792
805
                    forbidden_instructions=forbidden_instructions)
1793
622
                if instruction == RUN_INSTRUCTION:
806
                if instruction == RUN_INSTRUCTION:
1794
623
                    self.parse_whitespace("the command")
807
                    self.parse_whitespace("the command")
1795
624
                    command = self.take_to_newline().strip()
808
                    command = self.take_to_newline().strip()
1796
@@ -629,13 +813,25 @@
1797
629
                    url = self.parse_branch_url()
813
                    url = self.parse_branch_url()
1798
630
                    if instruction == NEST_INSTRUCTION:
814
                    if instruction == NEST_INSTRUCTION:
1799
631
                        location = self.parse_branch_location()
815
                        location = self.parse_branch_location()
1801
632
                    revspec = self.parse_optional_revspec()
816
                    if instruction == NEST_PART_INSTRUCTION:
1802
817
                        path = self.parse_subpath()
1803
818
                        target_subdir = self.parse_optional_path()
1804
819
                        if target_subdir == '':
1805
820
                            target_subdir = None
1806
821
                            revspec = None
1807
822
                        else:
1808
823
                            revspec = self.parse_optional_revspec()
1809
824
                    else:
1810
825
                        revspec = self.parse_optional_revspec()
1811
633
                    self.new_line()
826
                    self.new_line()
1812
634
                    last_branch = RecipeBranch(branch_id, url, revspec=revspec)
827
                    last_branch = RecipeBranch(branch_id, url, revspec=revspec)
1813
635
                    if instruction == NEST_INSTRUCTION:
828
                    if instruction == NEST_INSTRUCTION:
1814
636
                        active_branches[-1].nest_branch(location, last_branch)
829
                        active_branches[-1].nest_branch(location, last_branch)
1816
637
                    else:
830
                    elif instruction == MERGE_INSTRUCTION:
1817
638
                        active_branches[-1].merge_branch(last_branch)
831
                        active_branches[-1].merge_branch(last_branch)
1818
832
                    elif instruction == NEST_PART_INSTRUCTION:
1819
833
                        active_branches[-1].nest_part_branch(
1820
834
                            last_branch, path, target_subdir)
1821
639
                last_instruction = instruction
835
                last_instruction = instruction
1822
640
        if len(active_branches) == 0:
836
        if len(active_branches) == 0:
1823
641
            self.throw_parse_error("Empty recipe")
837
            self.throw_parse_error("Empty recipe")
1824
@@ -655,18 +851,28 @@
1825
655
        self.new_line()
851
        self.new_line()
1826
656
        return version, deb_version
852
        return version, deb_version
1827
657
853
1829
658
    def parse_instruction(self):
854
    def parse_instruction(self, forbidden_instructions=None):
1830
659
        if self.version < 0.2:
855
        if self.version < 0.2:
1831
660
            options = (MERGE_INSTRUCTION, NEST_INSTRUCTION)
856
            options = (MERGE_INSTRUCTION, NEST_INSTRUCTION)
1832
661
            options_str = "'%s' or '%s'" % options
857
            options_str = "'%s' or '%s'" % options
1834
662
        else:
858
        elif self.version < 0.3:
1835
663
            options = (MERGE_INSTRUCTION, NEST_INSTRUCTION, RUN_INSTRUCTION)
859
            options = (MERGE_INSTRUCTION, NEST_INSTRUCTION, RUN_INSTRUCTION)
1836
664
            options_str = "'%s', '%s' or '%s'" % options
860
            options_str = "'%s', '%s' or '%s'" % options
1837
861
        else:
1838
862
            options = (MERGE_INSTRUCTION, NEST_INSTRUCTION,
1839
863
                NEST_PART_INSTRUCTION, RUN_INSTRUCTION)
1840
864
            options_str = "'%s', '%s', '%s' or '%s'" % options
1841
665
        instruction = self.peek_to_whitespace()
865
        instruction = self.peek_to_whitespace()
1842
666
        if instruction is None:
866
        if instruction is None:
1843
667
            self.throw_parse_error("End of line while looking for %s"
867
            self.throw_parse_error("End of line while looking for %s"
1844
668
                    % options_str)
868
                    % options_str)
1845
669
        if instruction in options:
869
        if instruction in options:
1846
870
            if forbidden_instructions is not None:
1847
871
                if instruction in forbidden_instructions:
1848
872
                    self.throw_parse_error("The '%s' instruction is "
1849
873
                            "forbidden." % instruction,
1850
874
                            cls=ForbiddenInstructionError,
1851
875
                            instruction_name=instruction)
1852
670
            self.take_chars(len(instruction))
876
            self.take_chars(len(instruction))
1853
671
            return instruction
877
            return instruction
1854
672
        self.throw_parse_error("Expecting %s, got '%s'"
878
        self.throw_parse_error("Expecting %s, got '%s'"
1855
@@ -674,7 +880,15 @@
1856
674
880
1857
675
    def parse_branch_id(self):
881
    def parse_branch_id(self):
1858
676
        self.parse_whitespace("the branch id")
882
        self.parse_whitespace("the branch id")
1860
677
        branch_id = self.take_to_whitespace("the branch id")
883
        branch_id = self.peek_to_whitespace()
1861
884
        if branch_id is None:
1862
885
            self.throw_parse_error("End of line while looking for the "
1863
886
                    "branch id")
1864
887
        if branch_id in self.seen_nicks:
1865
888
            self.throw_parse_error("'%s' was already used to identify "
1866
889
                    "a branch." % branch_id)
1867
890
        self.take_chars(len(branch_id))
1868
891
        self.seen_nicks.add(branch_id)
1869
678
        return branch_id
892
        return branch_id
1870
679
893
1871
680
    def parse_branch_url(self):
894
    def parse_branch_url(self):
1872
@@ -685,8 +899,34 @@
1873
685
    def parse_branch_location(self):
899
    def parse_branch_location(self):
1874
686
        # FIXME: Needs a better term
900
        # FIXME: Needs a better term
1875
687
        self.parse_whitespace("the location to nest")
901
        self.parse_whitespace("the location to nest")
1878
688
        location = self.take_to_whitespace("the location to nest")
902
        location = self.peek_to_whitespace()
1879
689
        return location
903
        if location is None:
1880
904
            self.throw_parse_error("End of line while looking for the "
1881
905
                    "location to nest")
1882
906
        norm_location = os.path.normpath(location)
1883
907
        if norm_location in self.seen_paths:
1884
908
            self.throw_parse_error("The path '%s' is a duplicate of "
1885
909
                    "the one used on line %d." % (location,
1886
910
                        self.seen_paths[norm_location]))
1887
911
        if os.path.isabs(norm_location):
1888
912
            self.throw_parse_error("Absolute paths are not allowed: %s"
1889
913
                    % location)
1890
914
        if norm_location.startswith(".."):
1891
915
            self.throw_parse_error("Paths outside the current directory "
1892
916
                    "are not allowed: %s" % location)
1893
917
        self.take_chars(len(location))
1894
918
        self.seen_paths[norm_location] = self.line_index + 1
1895
919
        return location
1896
920
1897
921
    def parse_subpath(self):
1898
922
        self.parse_whitespace("the subpath to merge")
1899
923
        location = self.take_to_whitespace("the subpath to merge")
1900
924
        return location
1901
925
1902
926
    def parse_revspec(self):
1903
927
        self.parse_whitespace("the revspec")
1904
928
        revspec = self.take_to_whitespace("the revspec")
1905
929
        return revspec
1906
690
930
1907
691
    def parse_optional_revspec(self):
931
    def parse_optional_revspec(self):
1908
692
        self.parse_whitespace(None, require=False)
932
        self.parse_whitespace(None, require=False)
1909
@@ -695,9 +935,18 @@
1910
695
            self.take_chars(len(revspec))
935
            self.take_chars(len(revspec))
1911
696
        return revspec
936
        return revspec
1912
697
937
1916
698
    def throw_parse_error(self, problem):
938
    def parse_optional_path(self):
1917
699
        raise RecipeParseError(self.filename, self.line_index + 1,
939
        self.parse_whitespace(None, require=False)
1918
700
                self.index + 1, problem)
940
        path = self.peek_to_whitespace()
1919
941
        if path is not None:
1920
942
            self.take_chars(len(path))
1921
943
        return path
1922
944
1923
945
    def throw_parse_error(self, problem, cls=None, **kwargs):
1924
946
        if cls is None:
1925
947
            cls = RecipeParseError
1926
948
        raise cls(self.filename, self.line_index + 1,
1927
949
                self.index + 1, problem, **kwargs)
1928
701
950
1929
702
    def throw_expecting_error(self, expected, actual):
951
    def throw_expecting_error(self, expected, actual):
1930
703
        self.throw_parse_error("Expecting '%s', got '%s'"
952
        self.throw_parse_error("Expecting '%s', got '%s'"
1931
@@ -720,6 +969,12 @@
1932
720
        else:
969
        else:
1933
721
            self.current_line = self.lines[self.line_index]
970
            self.current_line = self.lines[self.line_index]
1934
722
971
1935
972
    def is_blankline(self):
1936
973
        whitespace = self.peek_whitespace()
1937
974
        if whitespace is None:
1938
975
            return True
1939
976
        return self.peek_char(skip=len(whitespace)) is None
1940
977
1941
723
    def take_char(self):
978
    def take_char(self):
1942
724
        if self.index >= len(self.current_line):
979
        if self.index >= len(self.current_line):
1943
725
            return None
980
            return None
1944
@@ -789,6 +1044,18 @@
1945
789
            actual = self.peek_char()
1044
            actual = self.peek_char()
1946
790
        return ret
1045
        return ret
1947
791
1046
1948
1047
    def peek_whitespace(self):
1949
1048
        ret = ""
1950
1049
        char = self.peek_char()
1951
1050
        if char is None:
1952
1051
            return char
1953
1052
        count = 0
1954
1053
        while char is not None and char in self.whitespace_chars:
1955
1054
            ret += char
1956
1055
            count += 1
1957
1056
            char = self.peek_char(skip=count)
1958
1057
        return ret
1959
1058
1960
792
    def parse_word(self, expected, require_whitespace=True):
1059
    def parse_word(self, expected, require_whitespace=True):
1961
793
        self.parse_whitespace("'%s'" % expected, require=require_whitespace)
1060
        self.parse_whitespace("'%s'" % expected, require=require_whitespace)
1962
794
        length = len(expected)
1061
        length = len(expected)
1963
@@ -865,10 +1132,14 @@
1964
865
        return text
1132
        return text
1965
866
1133
1966
867
    def parse_comment_line(self):
1134
    def parse_comment_line(self):
1970
868
        if self.peek_char() is None:
1135
        whitespace = self.peek_whitespace()
1971
869
            return ""
1136
        if whitespace is None:
1972
870
        if self.peek_char() != "#":
1137
            return ""
1973
1138
        if self.peek_char(skip=len(whitespace)) is None:
1974
1139
            return ""
1975
1140
        if self.peek_char(skip=len(whitespace)) != "#":
1976
871
            return None
1141
            return None
1977
1142
        self.parse_whitespace(None, require=False)
1978
872
        comment = self.current_line[self.index:]
1143
        comment = self.current_line[self.index:]
1979
873
        self.index += len(comment)
1144
        self.index += len(comment)
1980
874
        return comment
1145
        return comment
1981
875
1146
1982
=== modified file 'setup.py'
1983
--- setup.py	2009-08-25 11:43:42 +0000
1984
+++ setup.py	2010-08-13 01:14:42 +0000
1985
@@ -2,15 +2,16 @@
1986
2
2
1987
3
from distutils.core import setup
3
from distutils.core import setup
1988
4
4
2001
5
setup(name="bzr-builder",
5
if __name__ == '__main__':
2002
6
      version="0.1",
6
    setup(name="bzr-builder",
2003
7
      description="Turn a recipe in to a bzr branch",
7
          version="0.2",
2004
8
      author="James Westby",
8
          description="Turn a recipe in to a bzr branch",
2005
9
      author_email="james.westby@canonical.com",
9
          author="James Westby",
2006
10
      license="GNU GPL v3",
10
          author_email="james.westby@canonical.com",
2007
11
      url="http://launchpad.net/bzr-builder",
11
          license="GNU GPL v3",
2008
12
      packages=['bzrlib.plugins.builder',
12
          url="http://launchpad.net/bzr-builder",
2009
13
                'bzrlib.plugins.builder.tests',
13
          packages=['bzrlib.plugins.builder',
2010
14
               ],
14
                    'bzrlib.plugins.builder.tests',
2011
15
      package_dir={'bzrlib.plugins.builder': '.'},
15
                   ],
2012
16
     )
16
          package_dir={'bzrlib.plugins.builder': '.'},
2013
17
         )
2014
17
18
2015
=== modified file 'tests/__init__.py'
2016
--- tests/__init__.py	2009-04-16 20:23:39 +0000
2017
+++ tests/__init__.py	2010-08-13 01:14:42 +0000
2018
@@ -20,9 +20,10 @@
2019
20
    loader = TestUtil.TestLoader()
20
    loader = TestUtil.TestLoader()
2020
21
    suite = TestSuite()
21
    suite = TestSuite()
2021
22
    testmod_names = [
22
    testmod_names = [
2024
23
            'test_blackbox',
23
            'blackbox',
2025
24
            'test_recipe',
24
            'ppa',
2026
25
            'recipe',
2027
25
            ]
26
            ]
2029
26
    suite.addTest(loader.loadTestsFromModuleNames(["%s.%s" % (__name__, i)
27
    suite.addTest(loader.loadTestsFromModuleNames(["%s.test_%s" % (__name__, i)
2030
27
                                            for i in testmod_names]))
28
                                            for i in testmod_names]))
2031
28
    return suite
29
    return suite
2032
29
30
2033
=== modified file 'tests/test_blackbox.py'
2034
--- tests/test_blackbox.py	2010-08-13 01:14:42 +0000
2035
+++ tests/test_blackbox.py	2010-08-13 01:14:42 +0000
2036
@@ -55,7 +55,7 @@
2037
55
        self.build_tree(["source/a"])
55
        self.build_tree(["source/a"])
2038
56
        source.add(["a"])
56
        source.add(["a"])
2039
57
        revid = source.commit("one")
57
        revid = source.commit("one")
2041
58
        self.run_bzr("build recipe working")
58
        self.run_bzr("build -q recipe working")
2042
59
        self.failUnlessExists("working/a")
59
        self.failUnlessExists("working/a")
2043
60
        tree = workingtree.WorkingTree.open("working")
60
        tree = workingtree.WorkingTree.open("working")
2044
61
        self.assertEqual(revid, tree.last_revision())
61
        self.assertEqual(revid, tree.last_revision())
2045
@@ -71,7 +71,7 @@
2046
71
        self.build_tree(["source/a"])
71
        self.build_tree(["source/a"])
2047
72
        source.add(["a"])
72
        source.add(["a"])
2048
73
        revid = source.commit("one")
73
        revid = source.commit("one")
2050
74
        self.run_bzr("build recipe working --manifest manifest")
74
        self.run_bzr("build -q recipe working --manifest manifest")
2051
75
        self.failUnlessExists("working/a")
75
        self.failUnlessExists("working/a")
2052
76
        self.failUnlessExists("manifest")
76
        self.failUnlessExists("manifest")
2053
77
        self.check_file_contents("manifest", "# bzr-builder format 0.1 "
77
        self.check_file_contents("manifest", "# bzr-builder format 0.1 "
2054
@@ -83,7 +83,7 @@
2055
83
        source = self.make_branch_and_tree("source")
83
        source = self.make_branch_and_tree("source")
2056
84
        self.build_tree(["source/a"])
84
        self.build_tree(["source/a"])
2057
85
        source.add(["a"])
85
        source.add(["a"])
2059
86
        revid = source.commit("one")
86
        source.commit("one")
2060
87
        out, err = self.run_bzr("build recipe working "
87
        out, err = self.run_bzr("build recipe working "
2061
88
                "--if-changed-from manifest")
88
                "--if-changed-from manifest")
2062
89
89
2063
@@ -111,7 +111,7 @@
2064
111
                    "deb-version 1\nsource 1\n")])
111
                    "deb-version 1\nsource 1\n")])
2065
112
        self.build_tree_contents([("old-manifest", "# bzr-builder format 0.1 "
112
        self.build_tree_contents([("old-manifest", "# bzr-builder format 0.1 "
2066
113
                    "deb-version 1\nsource revid:foo\n")])
113
                    "deb-version 1\nsource revid:foo\n")])
2068
114
        out, err = self.run_bzr("build recipe working --manifest manifest "
114
        out, err = self.run_bzr("build -q recipe working --manifest manifest "
2069
115
                "--if-changed-from old-manifest")
115
                "--if-changed-from old-manifest")
2070
116
        self.failUnlessExists("working/a")
116
        self.failUnlessExists("working/a")
2071
117
        self.failUnlessExists("manifest")
117
        self.failUnlessExists("manifest")
2072
@@ -130,7 +130,7 @@
2073
130
        revid = source.commit("one")
130
        revid = source.commit("one")
2074
131
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
131
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2075
132
                    "deb-version 1\nsource 1\n")])
132
                    "deb-version 1\nsource 1\n")])
2077
133
        out, err = self.run_bzr("dailydeb test.recipe working "
133
        out, err = self.run_bzr("dailydeb -q test.recipe working "
2078
134
                "--manifest manifest --package foo")
134
                "--manifest manifest --package foo")
2079
135
        self.failIfExists("working/a")
135
        self.failIfExists("working/a")
2080
136
        package_root = "working/foo-1/"
136
        package_root = "working/foo-1/"
2081
@@ -149,13 +149,14 @@
2082
149
        cl_f = open(cl_path)
149
        cl_f = open(cl_path)
2083
150
        try:
150
        try:
2084
151
            line = cl_f.readline()
151
            line = cl_f.readline()
2086
152
            self.assertEqual("foo (1) jaunty; urgency=low\n", line)
152
            self.assertEqual("foo (1) lucid; urgency=low\n", line)
2087
153
        finally:
153
        finally:
2088
154
            cl_f.close()
154
            cl_f.close()
2089
155
155
2090
156
    def test_cmd_dailydeb_no_work_dir(self):
156
    def test_cmd_dailydeb_no_work_dir(self):
2091
157
        #TODO: define a test feature for debuild and require it here.
157
        #TODO: define a test feature for debuild and require it here.
2093
158
        self.permit_dir('/') # Allow the made working dir to be accessed.
158
        if getattr(self, "permit_dir", None) is not None:
2094
159
            self.permit_dir('/') # Allow the made working dir to be accessed.
2095
159
        source = self.make_branch_and_tree("source")
160
        source = self.make_branch_and_tree("source")
2096
160
        self.build_tree(["source/a", "source/debian/"])
161
        self.build_tree(["source/a", "source/debian/"])
2097
161
        self.build_tree_contents([("source/debian/rules",
162
        self.build_tree_contents([("source/debian/rules",
2098
@@ -163,15 +164,16 @@
2099
163
                ("source/debian/control",
164
                ("source/debian/control",
2100
164
                    "Source: foo\nMaintainer: maint maint@maint.org\n")])
165
                    "Source: foo\nMaintainer: maint maint@maint.org\n")])
2101
165
        source.add(["a", "debian/", "debian/rules", "debian/control"])
166
        source.add(["a", "debian/", "debian/rules", "debian/control"])
2103
166
        revid = source.commit("one")
167
        source.commit("one")
2104
167
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
168
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2105
168
                    "deb-version 1\nsource 1\n")])
169
                    "deb-version 1\nsource 1\n")])
2107
169
        out, err = self.run_bzr("dailydeb test.recipe "
170
        out, err = self.run_bzr("dailydeb -q test.recipe "
2108
170
                "--manifest manifest --package foo")
171
                "--manifest manifest --package foo")
2109
171
172
2110
172
    def test_cmd_dailydeb_if_changed_from_non_existant(self):
173
    def test_cmd_dailydeb_if_changed_from_non_existant(self):
2111
173
        #TODO: define a test feature for debuild and require it here.
174
        #TODO: define a test feature for debuild and require it here.
2113
174
        self.permit_dir('/') # Allow the made working dir to be accessed.
175
        if getattr(self, "permit_dir", None) is not None:
2114
176
            self.permit_dir('/') # Allow the made working dir to be accessed.
2115
175
        source = self.make_branch_and_tree("source")
177
        source = self.make_branch_and_tree("source")
2116
176
        self.build_tree(["source/a", "source/debian/"])
178
        self.build_tree(["source/a", "source/debian/"])
2117
177
        self.build_tree_contents([("source/debian/rules",
179
        self.build_tree_contents([("source/debian/rules",
2118
@@ -179,10 +181,10 @@
2119
179
                ("source/debian/control",
181
                ("source/debian/control",
2120
180
                    "Source: foo\nMaintainer: maint maint@maint.org\n")])
182
                    "Source: foo\nMaintainer: maint maint@maint.org\n")])
2121
181
        source.add(["a", "debian/", "debian/rules", "debian/control"])
183
        source.add(["a", "debian/", "debian/rules", "debian/control"])
2123
182
        revid = source.commit("one")
184
        source.commit("one")
2124
183
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
185
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2125
184
                    "deb-version 1\nsource 1\n")])
186
                    "deb-version 1\nsource 1\n")])
2127
185
        out, err = self.run_bzr("dailydeb test.recipe "
187
        out, err = self.run_bzr("dailydeb -q test.recipe "
2128
186
                "--manifest manifest --package foo --if-changed-from bar")
188
                "--manifest manifest --package foo --if-changed-from bar")
2129
187
189
2130
188
    def make_simple_package(self):
190
    def make_simple_package(self):
2131
@@ -201,12 +203,29 @@
2132
201
        source.commit("one")
203
        source.commit("one")
2133
202
        return source
204
        return source
2134
203
205
2135
206
    def test_cmd_dailydeb_no_build(self):
2136
207
        self.make_simple_package()
2137
208
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2138
209
                    "deb-version 1\nsource 1\n")])
2139
210
        out, err = self.run_bzr("dailydeb -q test.recipe "
2140
211
                "--manifest manifest --no-build working")
2141
212
        new_cl_contents = ("package (1) unstable; urgency=low\n\n"
2142
213
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
2143
214
        f = open("working/test-1/debian/changelog")
2144
215
        try:
2145
216
            actual_cl_contents = f.read()
2146
217
        finally:
2147
218
            f.close()
2148
219
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
2149
220
        for fn in os.listdir("working"):
2150
221
            self.assertFalse(fn.endswith(".changes"))
2151
222
2152
204
    def test_cmd_dailydeb_with_package_from_changelog(self):
223
    def test_cmd_dailydeb_with_package_from_changelog(self):
2153
205
        #TODO: define a test feature for debuild and require it here.
224
        #TODO: define a test feature for debuild and require it here.
2155
206
        source = self.make_simple_package()
225
        self.make_simple_package()
2156
207
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
226
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2157
208
                    "deb-version 1\nsource 1\n")])
227
                    "deb-version 1\nsource 1\n")])
2159
209
        out, err = self.run_bzr("dailydeb test.recipe "
228
        out, err = self.run_bzr("dailydeb -q test.recipe "
2160
210
                "--manifest manifest --if-changed-from bar working")
229
                "--manifest manifest --if-changed-from bar working")
2161
211
        new_cl_contents = ("package (1) unstable; urgency=low\n\n"
230
        new_cl_contents = ("package (1) unstable; urgency=low\n\n"
2162
212
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
231
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
2163
@@ -218,10 +237,10 @@
2164
218
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
237
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
2165
219
238
2166
220
    def test_cmd_dailydeb_with_upstream_version_from_changelog(self):
239
    def test_cmd_dailydeb_with_upstream_version_from_changelog(self):
2168
221
        source = self.make_simple_package()
240
        self.make_simple_package()
2169
222
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
241
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2170
223
                    "deb-version {debupstream}-2\nsource 1\n")])
242
                    "deb-version {debupstream}-2\nsource 1\n")])
2172
224
        out, err = self.run_bzr("dailydeb test.recipe working")
243
        out, err = self.run_bzr("dailydeb -q test.recipe working")
2173
225
        new_cl_contents = ("package (0.1-2) unstable; urgency=low\n\n"
244
        new_cl_contents = ("package (0.1-2) unstable; urgency=low\n\n"
2174
226
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
245
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
2175
227
        f = open("working/test-{debupstream}-2/debian/changelog")
246
        f = open("working/test-{debupstream}-2/debian/changelog")
2176
@@ -230,3 +249,30 @@
2177
230
        finally:
249
        finally:
2178
231
            f.close()
250
            f.close()
2179
232
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
251
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
2180
252
2181
253
    def test_cmd_dailydeb_with_append_version(self):
2182
254
        self.make_simple_package()
2183
255
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2184
256
                    "deb-version 1\nsource 1\n")])
2185
257
        out, err = self.run_bzr("dailydeb -q test.recipe working "
2186
258
                "--append-version ~ppa1")
2187
259
        new_cl_contents = ("package (1~ppa1) unstable; urgency=low\n\n"
2188
260
                "  * Auto build.\n\n -- M. Maintainer <maint@maint.org>  ")
2189
261
        f = open("working/test-1/debian/changelog")
2190
262
        try:
2191
263
            actual_cl_contents = f.read()
2192
264
        finally:
2193
265
            f.close()
2194
266
        self.assertStartsWith(actual_cl_contents, new_cl_contents)
2195
267
2196
268
    def test_cmd_dailydeb_with_invalid_version(self):
2197
269
        source = self.make_branch_and_tree("source")
2198
270
        self.build_tree(["source/a"])
2199
271
        source.add(["a"])
2200
272
        revid = source.commit("one")
2201
273
        self.build_tree_contents([("test.recipe", "# bzr-builder format 0.1 "
2202
274
                    "deb-version $\nsource 1\n")])
2203
275
        err = self.run_bzr("dailydeb -q test.recipe working --package foo",
2204
276
                retcode=3)[1]
2205
277
        self.assertEqual("bzr: ERROR: Invalid deb-version: $: "
2206
278
                "Could not parse version: $\n", err)
2207
233
279
2208
=== added file 'tests/test_ppa.py'
2209
--- tests/test_ppa.py	1970-01-01 00:00:00 +0000
2210
+++ tests/test_ppa.py	2010-08-13 01:14:42 +0000
2211
@@ -0,0 +1,28 @@
2212
1
# bzr-builder: a bzr plugin to construct trees based on recipes
2213
2
# Copyright 2009 Canonical Ltd.
2214
3
2215
4
# This program is free software: you can redistribute it and/or modify it 
2216
5
# under the terms of the GNU General Public License version 3, as published 
2217
6
# by the Free Software Foundation.
2218
7
2219
8
# This program is distributed in the hope that it will be useful, but 
2220
9
# WITHOUT ANY WARRANTY; without even the implied warranties of 
2221
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
2222
11
# PURPOSE.  See the GNU General Public License for more details.
2223
12
2224
13
# You should have received a copy of the GNU General Public License along 
2225
14
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2226
15
2227
16
from bzrlib.plugins.builder.cmds import target_from_dput
2228
17
from bzrlib.tests import (
2229
18
        TestCase,
2230
19
        )
2231
20
2232
21
2233
22
class TestTargetFromDPut(TestCase):
2234
23
2235
24
    def test_default_ppa(self):
2236
25
        self.assertEqual('team-name/ppa', target_from_dput('ppa:team-name'))
2237
26
2238
27
    def test_named_ppa(self):
2239
28
        self.assertEqual('team/ppa2', target_from_dput('ppa:team/ppa2'))
2240
0
29
2241
=== modified file 'tests/test_recipe.py'
2242
--- tests/test_recipe.py	2010-08-13 01:14:42 +0000
2243
+++ tests/test_recipe.py	2010-08-13 01:14:42 +0000
2244
@@ -27,26 +27,28 @@
2245
27
        )
27
        )
2246
28
from bzrlib.plugins.builder.recipe import (
28
from bzrlib.plugins.builder.recipe import (
2247
29
        BaseRecipeBranch,
29
        BaseRecipeBranch,
2248
30
        build_manifest,
2249
31
        build_tree,
30
        build_tree,
2250
32
        ensure_basedir,
31
        ensure_basedir,
2251
32
        ForbiddenInstructionError,
2252
33
        pull_or_branch,
33
        pull_or_branch,
2253
34
        RecipeParser,
34
        RecipeParser,
2254
35
        RecipeBranch,
35
        RecipeBranch,
2255
36
        RecipeParseError,
36
        RecipeParseError,
2256
37
        resolve_revisions,
37
        resolve_revisions,
2257
38
        RUN_INSTRUCTION,
2258
38
        )
39
        )
2259
39
40
2260
40
41
2261
41
class RecipeParserTests(TestCaseInTempDir):
42
class RecipeParserTests(TestCaseInTempDir):
2262
42
43
2263
43
    deb_version = "0.1-{revno}"
44
    deb_version = "0.1-{revno}"
2265
44
    basic_header = ("# bzr-builder format 0.2 deb-version "
45
    basic_header = ("# bzr-builder format 0.3 deb-version "
2266
45
            + deb_version +"\n")
46
            + deb_version +"\n")
2268
46
    basic_header_and_branch = basic_header + "http://foo.org/\n"
47
    basic_branch = "http://foo.org/"
2269
48
    basic_header_and_branch = basic_header + basic_branch + "\n"
2270
47
49
2273
48
    def get_recipe(self, recipe_text):
50
    def get_recipe(self, recipe_text, **kwargs):
2274
49
        return RecipeParser(recipe_text).parse()
51
        return RecipeParser(recipe_text).parse(**kwargs)
2275
50
52
2276
51
    def assertParseError(self, line, char, problem, callable, *args,
53
    def assertParseError(self, line, char, problem, callable, *args,
2277
52
            **kwargs):
54
            **kwargs):
2278
@@ -55,6 +57,7 @@
2279
55
        self.assertEqual(line, exc.line)
57
        self.assertEqual(line, exc.line)
2280
56
        self.assertEqual(char, exc.char)
58
        self.assertEqual(char, exc.char)
2281
57
        self.assertEqual("recipe", exc.filename)
59
        self.assertEqual("recipe", exc.filename)
2282
60
        return exc
2283
58
61
2284
59
    def check_recipe_branch(self, branch, name, url, revspec=None,
62
    def check_recipe_branch(self, branch, name, url, revspec=None,
2285
60
            num_child_branches=0, revid=None):
63
            num_child_branches=0, revid=None):
2286
@@ -130,8 +133,8 @@
2287
130
                self.basic_header + "http://foo.org/ 2 foo")
133
                self.basic_header + "http://foo.org/ 2 foo")
2288
131
134
2289
132
    def tests_rejects_unknown_instruction(self):
135
    def tests_rejects_unknown_instruction(self):
2292
133
        self.assertParseError(3, 1, "Expecting 'merge', 'nest' or 'run', "
136
        self.assertParseError(3, 1, "Expecting 'merge', 'nest', 'nest-part' "
2293
134
                "got 'cat'", self.get_recipe,
137
                "or 'run', got 'cat'", self.get_recipe,
2294
135
                self.basic_header + "http://foo.org/\n" + "cat")
138
                self.basic_header + "http://foo.org/\n" + "cat")
2295
136
139
2296
137
    def test_rejects_merge_no_name(self):
140
    def test_rejects_merge_no_name(self):
2297
@@ -149,6 +152,21 @@
2298
149
                "got 'bar'", self.get_recipe,
152
                "got 'bar'", self.get_recipe,
2299
150
                self.basic_header_and_branch + "merge foo url 2 bar")
153
                self.basic_header_and_branch + "merge foo url 2 bar")
2300
151
154
2301
155
    def test_rejects_nest_part_no_name(self):
2302
156
        self.assertParseError(3, 11, "End of line while looking for "
2303
157
                "the branch id", self.get_recipe,
2304
158
                self.basic_header_and_branch + "nest-part ")
2305
159
2306
160
    def test_rejects_nest_part_no_url(self):
2307
161
        self.assertParseError(3, 15, "End of line while looking for "
2308
162
                "the branch url", self.get_recipe,
2309
163
                self.basic_header_and_branch + "nest-part foo ")
2310
164
2311
165
    def test_rejects_nest_part_no_subpath(self):
2312
166
        self.assertParseError(3, 22, "End of line while looking for "
2313
167
                "the subpath to merge", self.get_recipe,
2314
168
                self.basic_header_and_branch + "nest-part foo url:// ")
2315
169
2316
152
    def test_rejects_nest_no_name(self):
170
    def test_rejects_nest_no_name(self):
2317
153
        self.assertParseError(3, 6, "End of line while looking for "
171
        self.assertParseError(3, 6, "End of line while looking for "
2318
154
                "the branch id", self.get_recipe,
172
                "the branch id", self.get_recipe,
2319
@@ -202,6 +220,12 @@
2320
202
        self.assertParseError(3, 1, "Empty recipe", self.get_recipe,
220
        self.assertParseError(3, 1, "Empty recipe", self.get_recipe,
2321
203
                self.basic_header)
221
                self.basic_header)
2322
204
222
2323
223
    def test_rejects_non_unique_ids(self):
2324
224
        self.assertParseError(4, 7, "'foo' was already used to identify "
2325
225
                "a branch.", self.get_recipe,
2326
226
                self.basic_header_and_branch + "merge foo url\n"
2327
227
                + "merge foo other-url\n")
2328
228
2329
205
    def test_builds_simplest_recipe(self):
229
    def test_builds_simplest_recipe(self):
2330
206
        base_branch = self.get_recipe(self.basic_header_and_branch)
230
        base_branch = self.get_recipe(self.basic_header_and_branch)
2331
207
        self.check_base_recipe_branch(base_branch, "http://foo.org/")
231
        self.check_base_recipe_branch(base_branch, "http://foo.org/")
2332
@@ -220,6 +244,42 @@
2333
220
        self.assertEqual(None, location)
244
        self.assertEqual(None, location)
2334
221
        self.check_recipe_branch(child_branch, "bar", "http://bar.org")
245
        self.check_recipe_branch(child_branch, "bar", "http://bar.org")
2335
222
246
2336
247
    def test_builds_recipe_with_nest_part(self):
2337
248
        base_branch = self.get_recipe(self.basic_header_and_branch
2338
249
                + "nest-part bar http://bar.org some/path")
2339
250
        self.check_base_recipe_branch(base_branch, "http://foo.org/",
2340
251
                num_child_branches=1)
2341
252
        instruction = base_branch.child_branches[0]
2342
253
        self.assertEqual(None, instruction.nest_path)
2343
254
        self.check_recipe_branch(
2344
255
            instruction.recipe_branch, "bar", "http://bar.org")
2345
256
        self.assertEqual("some/path", instruction.subpath)
2346
257
        self.assertEqual(None, instruction.target_subdir)
2347
258
2348
259
    def test_builds_recipe_with_nest_part_subdir(self):
2349
260
        base_branch = self.get_recipe(self.basic_header_and_branch
2350
261
                + "nest-part bar http://bar.org some/path target-subdir")
2351
262
        self.check_base_recipe_branch(base_branch, "http://foo.org/",
2352
263
                num_child_branches=1)
2353
264
        instruction = base_branch.child_branches[0]
2354
265
        self.assertEqual(None, instruction.nest_path)
2355
266
        self.check_recipe_branch(
2356
267
            instruction.recipe_branch, "bar", "http://bar.org")
2357
268
        self.assertEqual("some/path", instruction.subpath)
2358
269
        self.assertEqual("target-subdir", instruction.target_subdir)
2359
270
2360
271
    def test_builds_recipe_with_nest_part_subdir_and_revspec(self):
2361
272
        base_branch = self.get_recipe(self.basic_header_and_branch
2362
273
                + "nest-part bar http://bar.org some/path target-subdir 1234")
2363
274
        self.check_base_recipe_branch(base_branch, "http://foo.org/",
2364
275
                num_child_branches=1)
2365
276
        instruction = base_branch.child_branches[0]
2366
277
        self.assertEqual(None, instruction.nest_path)
2367
278
        self.check_recipe_branch(
2368
279
            instruction.recipe_branch, "bar", "http://bar.org", "1234")
2369
280
        self.assertEqual("some/path", instruction.subpath)
2370
281
        self.assertEqual("target-subdir", instruction.target_subdir)
2371
282
2372
223
    def test_builds_recipe_with_nest(self):
283
    def test_builds_recipe_with_nest(self):
2373
224
        base_branch = self.get_recipe(self.basic_header_and_branch
284
        base_branch = self.get_recipe(self.basic_header_and_branch
2374
225
                + "nest bar http://bar.org baz")
285
                + "nest bar http://bar.org baz")
2375
@@ -306,6 +366,60 @@
2376
306
        self.assertEqual(None, child_branch)
366
        self.assertEqual(None, child_branch)
2377
307
        self.assertEqual("touch test", command)
367
        self.assertEqual("touch test", command)
2378
308
368
2379
369
    def test_accepts_blank_line_during_nest(self):
2380
370
        base_branch = self.get_recipe(self.basic_header_and_branch
2381
371
                + "nest foo http://bar.org bar\n  merge baz baz.org\n\n"
2382
372
                "  merge zap zap.org\n")
2383
373
        self.check_base_recipe_branch(base_branch, self.basic_branch,
2384
374
                num_child_branches=1)
2385
375
        nested_branch, location = base_branch.child_branches[0].as_tuple()
2386
376
        self.assertEqual("bar", location)
2387
377
        self.check_recipe_branch(nested_branch, "foo", "http://bar.org",
2388
378
                num_child_branches=2)
2389
379
        child_branch, location = nested_branch.child_branches[0].as_tuple()
2390
380
        self.assertEqual(None, location)
2391
381
        self.check_recipe_branch(child_branch, "baz", "baz.org")
2392
382
        child_branch, location = nested_branch.child_branches[1].as_tuple()
2393
383
        self.assertEqual(None, location)
2394
384
        self.check_recipe_branch(child_branch, "zap", "zap.org")
2395
385
2396
386
    def test_accepts_blank_line_at_start_of_nest(self):
2397
387
        base_branch = self.get_recipe(self.basic_header_and_branch
2398
388
                + "nest foo http://bar.org bar\n\n  merge baz baz.org\n")
2399
389
        self.check_base_recipe_branch(base_branch, self.basic_branch,
2400
390
                num_child_branches=1)
2401
391
        nested_branch, location = base_branch.child_branches[0].as_tuple()
2402
392
        self.assertEqual("bar", location)
2403
393
        self.check_recipe_branch(nested_branch, "foo", "http://bar.org",
2404
394
                num_child_branches=1)
2405
395
        child_branch, location = nested_branch.child_branches[0].as_tuple()
2406
396
        self.assertEqual(None, location)
2407
397
        self.check_recipe_branch(child_branch, "baz", "baz.org")
2408
398
2409
399
    def test_accepts_blank_line_as_only_thing_in_nest(self):
2410
400
        base_branch = self.get_recipe(self.basic_header_and_branch
2411
401
                + "nest foo http://bar.org bar\n\nmerge baz baz.org\n")
2412
402
        self.check_base_recipe_branch(base_branch, self.basic_branch,
2413
403
                num_child_branches=2)
2414
404
        nested_branch, location = base_branch.child_branches[0].as_tuple()
2415
405
        self.assertEqual("bar", location)
2416
406
        self.check_recipe_branch(nested_branch, "foo", "http://bar.org")
2417
407
        child_branch, location = base_branch.child_branches[1].as_tuple()
2418
408
        self.assertEqual(None, location)
2419
409
        self.check_recipe_branch(child_branch, "baz", "baz.org")
2420
410
2421
411
    def test_accepts_comment_line_with_any_number_of_spaces(self):
2422
412
        base_branch = self.get_recipe(self.basic_header_and_branch
2423
413
                + "nest foo http://bar.org bar\n   #foo\nmerge baz baz.org\n")
2424
414
        self.check_base_recipe_branch(base_branch, self.basic_branch,
2425
415
                num_child_branches=2)
2426
416
        nested_branch, location = base_branch.child_branches[0].as_tuple()
2427
417
        self.assertEqual("bar", location)
2428
418
        self.check_recipe_branch(nested_branch, "foo", "http://bar.org")
2429
419
        child_branch, location = base_branch.child_branches[1].as_tuple()
2430
420
        self.assertEqual(None, location)
2431
421
        self.check_recipe_branch(child_branch, "baz", "baz.org")
2432
422
2433
309
    def test_old_format_rejects_run(self):
423
    def test_old_format_rejects_run(self):
2434
310
        header = ("# bzr-builder format 0.1 deb-version "
424
        header = ("# bzr-builder format 0.1 deb-version "
2435
311
                + self.deb_version +"\n")
425
                + self.deb_version +"\n")
2436
@@ -313,6 +427,45 @@
2437
313
                , self.get_recipe, header + "http://foo.org/\n"
427
                , self.get_recipe, header + "http://foo.org/\n"
2438
314
                + "run touch test \n")
428
                + "run touch test \n")
2439
315
429
2440
430
    def test_error_on_forbidden_instructions(self):
2441
431
        exc = self.assertParseError(3, 1, "The 'run' instruction is "
2442
432
                "forbidden.", self.get_recipe, self.basic_header_and_branch
2443
433
                + "run touch test\n",
2444
434
                forbidden_instructions=[RUN_INSTRUCTION])
2445
435
        self.assertTrue(isinstance(exc, ForbiddenInstructionError))
2446
436
        self.assertEqual("run", exc.instruction_name)
2447
437
2448
438
    def test_error_on_duplicate_path(self):
2449
439
        exc = self.assertParseError(3, 15, "The path '.' is a duplicate "
2450
440
                "of the one used on line 1.", self.get_recipe,
2451
441
                self.basic_header_and_branch + "nest nest url .\n")
2452
442
2453
443
    def test_error_on_duplicate_path_with_another_nest(self):
2454
444
        exc = self.assertParseError(4, 16, "The path 'foo' is a duplicate "
2455
445
                "of the one used on line 3.", self.get_recipe,
2456
446
                self.basic_header_and_branch + "nest nest url foo\n"
2457
447
                + "nest nest2 url foo\n")
2458
448
2459
449
    def test_duplicate_path_check_uses_normpath(self):
2460
450
        exc = self.assertParseError(3, 15, "The path 'foo/..' is a duplicate "
2461
451
                "of the one used on line 1.", self.get_recipe,
2462
452
                self.basic_header_and_branch + "nest nest url foo/..\n")
2463
453
2464
454
    def test_error_absolute_path(self):
2465
455
        exc = self.assertParseError(3, 15, "Absolute paths are not allowed: "
2466
456
                "/etc/passwd", self.get_recipe, self.basic_header_and_branch
2467
457
                + "nest nest url /etc/passwd\n")
2468
458
2469
459
    def test_error_simple_parent_dir(self):
2470
460
        exc = self.assertParseError(3, 15, "Paths outside the current "
2471
461
                "directory are not allowed: ../foo", self.get_recipe,
2472
462
                self.basic_header_and_branch + "nest nest url ../foo\n")
2473
463
2474
464
    def test_error_complex_parent_dir(self):
2475
465
        exc = self.assertParseError(3, 15, "Paths outside the current "
2476
466
                "directory are not allowed: ./foo/../..", self.get_recipe,
2477
467
                self.basic_header_and_branch + "nest nest url ./foo/../..\n")
2478
468
2479
316
469
2480
317
class BuildTreeTests(TestCaseWithTransport):
470
class BuildTreeTests(TestCaseWithTransport):
2481
318
471
2482
@@ -352,7 +505,7 @@
2483
352
    def test_build_tree_single_branch_existing_branch(self):
505
    def test_build_tree_single_branch_existing_branch(self):
2484
353
        source = self.make_branch_and_tree("source")
506
        source = self.make_branch_and_tree("source")
2485
354
        revid = source.commit("one")
507
        revid = source.commit("one")
2487
355
        target = self.make_branch_and_tree("target")
508
        self.make_branch_and_tree("target")
2488
356
        base_branch = BaseRecipeBranch("source", "1", 0.2)
509
        base_branch = BaseRecipeBranch("source", "1", 0.2)
2489
357
        build_tree(base_branch, "target")
510
        build_tree(base_branch, "target")
2490
358
        self.failUnlessExists("target")
511
        self.failUnlessExists("target")
2491
@@ -360,15 +513,17 @@
2492
360
        self.assertEqual(revid, tree.last_revision())
513
        self.assertEqual(revid, tree.last_revision())
2493
361
        self.assertEqual(revid, base_branch.revid)
514
        self.assertEqual(revid, base_branch.revid)
2494
362
515
2495
516
    def make_source_branch(self, relpath):
2496
517
        """Make a branch with one file and one commit."""
2497
518
        source1 = self.make_branch_and_tree(relpath)
2498
519
        self.build_tree([relpath + "/a"])
2499
520
        source1.add(["a"])
2500
521
        source1.commit("one")
2501
522
        return source1
2502
523
2503
363
    def test_build_tree_nested(self):
524
    def test_build_tree_nested(self):
2512
364
        source1 = self.make_branch_and_tree("source1")
525
        source1_rev_id = self.make_source_branch("source1").last_revision()
2513
365
        self.build_tree(["source1/a"])
526
        source2_rev_id = self.make_source_branch("source2").last_revision()
2506
366
        source1.add(["a"])
2507
367
        source1_rev_id = source1.commit("one")
2508
368
        source2 = self.make_branch_and_tree("source2")
2509
369
        self.build_tree(["source2/a"])
2510
370
        source2.add(["a"])
2511
371
        source2_rev_id = source2.commit("one")
2514
372
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
527
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
2515
373
        nested_branch = RecipeBranch("nested", "source2")
528
        nested_branch = RecipeBranch("nested", "source2")
2516
374
        base_branch.nest_branch("sub", nested_branch)
529
        base_branch.nest_branch("sub", nested_branch)
2517
@@ -382,10 +537,8 @@
2518
382
        self.assertEqual(source2_rev_id, nested_branch.revid)
537
        self.assertEqual(source2_rev_id, nested_branch.revid)
2519
383
538
2520
384
    def test_build_tree_merged(self):
539
    def test_build_tree_merged(self):
2525
385
        source1 = self.make_branch_and_tree("source1")
540
        source1 = self.make_source_branch("source1")
2526
386
        self.build_tree(["source1/a"])
541
        source1_rev_id = source1.last_revision()
2523
387
        source1.add(["a"])
2524
388
        source1_rev_id = source1.commit("one")
2527
389
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
542
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
2528
390
        self.build_tree_contents([("source2/a", "other change")])
543
        self.build_tree_contents([("source2/a", "other change")])
2529
391
        source2_rev_id = source2.commit("one")
544
        source2_rev_id = source2.commit("one")
2530
@@ -403,11 +556,60 @@
2531
403
        self.assertEqual(source1_rev_id, base_branch.revid)
556
        self.assertEqual(source1_rev_id, base_branch.revid)
2532
404
        self.assertEqual(source2_rev_id, merged_branch.revid)
557
        self.assertEqual(source2_rev_id, merged_branch.revid)
2533
405
558
2534
559
    def test_build_tree_nest_part(self):
2535
560
        """A recipe can specify a merge of just part of an unrelated tree."""
2536
561
        source1 = self.make_source_branch("source1")
2537
562
        source2 = self.make_source_branch("source2")
2538
563
        source1.lock_read()
2539
564
        self.addCleanup(source1.unlock)
2540
565
        source1_rev_id = source1.last_revision()
2541
566
        # Add 'b' to source2.
2542
567
        self.build_tree_contents([
2543
568
            ("source2/b", "new file"), ("source2/not-b", "other file")])
2544
569
        source2.add(["b", "not-b"])
2545
570
        source2_rev_id = source2.commit("two")
2546
571
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
2547
572
        merged_branch = RecipeBranch("merged", "source2")
2548
573
        # Merge just 'b' from source2; 'a' is untouched.
2549
574
        base_branch.nest_part_branch(merged_branch, "b")
2550
575
        build_tree(base_branch, "target")
2551
576
        file_id = source1.path2id("a")
2552
577
        self.check_file_contents("target/a", source1.get_file_text(file_id))
2553
578
        self.check_file_contents("target/b", "new file")
2554
579
        self.assertNotInWorkingTree("not-b", "target")
2555
580
        self.assertEqual(source1_rev_id, base_branch.revid)
2556
581
        self.assertEqual(source2_rev_id, merged_branch.revid)
2557
582
2558
583
    def test_build_tree_nest_part_explicit_target(self):
2559
584
        """A recipe can specify a merge of just part of an unrelated tree into
2560
585
        a specific subdirectory of the target tree.
2561
586
        """
2562
587
        source1 = self.make_branch_and_tree("source1")
2563
588
        self.build_tree(["source1/dir/"])
2564
589
        source1.add(["dir"])
2565
590
        source1.commit("one")
2566
591
        source2 = self.make_source_branch("source2")
2567
592
        source1.lock_read()
2568
593
        self.addCleanup(source1.unlock)
2569
594
        source1_rev_id = source1.last_revision()
2570
595
        # Add 'b' to source2.
2571
596
        self.build_tree_contents([
2572
597
            ("source2/b", "new file"), ("source2/not-b", "other file")])
2573
598
        source2.add(["b", "not-b"])
2574
599
        source2_rev_id = source2.commit("two")
2575
600
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
2576
601
        merged_branch = RecipeBranch("merged", "source2")
2577
602
        # Merge just 'b' from source2; 'a' is untouched.
2578
603
        base_branch.nest_part_branch(merged_branch, "b", "dir/b")
2579
604
        build_tree(base_branch, "target")
2580
605
        self.check_file_contents("target/dir/b", "new file")
2581
606
        self.assertNotInWorkingTree("dir/not-b", "target")
2582
607
        self.assertEqual(source1_rev_id, base_branch.revid)
2583
608
        self.assertEqual(source2_rev_id, merged_branch.revid)
2584
609
2585
406
    def test_build_tree_merge_twice(self):
610
    def test_build_tree_merge_twice(self):
2590
407
        source1 = self.make_branch_and_tree("source1")
611
        source1 = self.make_source_branch("source1")
2591
408
        self.build_tree(["source1/a"])
612
        source1_rev_id = source1.last_revision()
2588
409
        source1.add(["a"])
2589
410
        source1_rev_id = source1.commit("one")
2592
411
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
613
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
2593
412
        self.build_tree_contents([("source2/a", "other change")])
614
        self.build_tree_contents([("source2/a", "other change")])
2594
413
        source2_rev_id = source2.commit("one")
615
        source2_rev_id = source2.commit("one")
2595
@@ -436,10 +638,7 @@
2596
436
        self.assertEqual(source3_rev_id, merged_branch2.revid)
638
        self.assertEqual(source3_rev_id, merged_branch2.revid)
2597
437
639
2598
438
    def test_build_tree_merged_with_conflicts(self):
640
    def test_build_tree_merged_with_conflicts(self):
2603
439
        source1 = self.make_branch_and_tree("source1")
641
        source1 = self.make_source_branch("source1")
2600
440
        self.build_tree(["source1/a"])
2601
441
        source1.add(["a"])
2602
442
        source1_rev_id = source1.commit("one")
2604
443
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
642
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
2605
444
        self.build_tree_contents([("source2/a", "other change\n")])
643
        self.build_tree_contents([("source2/a", "other change\n")])
2606
445
        source2_rev_id = source2.commit("one")
644
        source2_rev_id = source2.commit("one")
2607
@@ -448,7 +647,7 @@
2608
448
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
647
        base_branch = BaseRecipeBranch("source1", "1", 0.2)
2609
449
        merged_branch = RecipeBranch("merged", "source2")
648
        merged_branch = RecipeBranch("merged", "source2")
2610
450
        base_branch.merge_branch(merged_branch)
649
        base_branch.merge_branch(merged_branch)
2612
451
        e = self.assertRaises(errors.BzrCommandError, build_tree,
650
        self.assertRaises(errors.BzrCommandError, build_tree,
2613
452
                base_branch, "target")
651
                base_branch, "target")
2614
453
        self.failUnlessExists("target")
652
        self.failUnlessExists("target")
2615
454
        tree = workingtree.WorkingTree.open("target")
653
        tree = workingtree.WorkingTree.open("target")
2616
@@ -465,10 +664,8 @@
2617
465
        self.assertEqual(source2_rev_id, merged_branch.revid)
664
        self.assertEqual(source2_rev_id, merged_branch.revid)
2618
466
665
2619
467
    def test_build_tree_with_revspecs(self):
666
    def test_build_tree_with_revspecs(self):
2624
468
        source1 = self.make_branch_and_tree("source1")
667
        source1 = self.make_source_branch("source1")
2625
469
        self.build_tree(["source1/a"])
668
        source1_rev_id = source1.last_revision()
2622
470
        source1.add(["a"])
2623
471
        source1_rev_id = source1.commit("one")
2626
472
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
669
        source2 = source1.bzrdir.sprout("source2").open_workingtree()
2627
473
        self.build_tree_contents([("source2/a", "other change\n")])
670
        self.build_tree_contents([("source2/a", "other change\n")])
2628
474
        source2_rev_id = source2.commit("one")
671
        source2_rev_id = source2.commit("one")
2629
@@ -622,6 +819,20 @@
2630
622
        self.assertEqual(revid, tree.last_revision())
819
        self.assertEqual(revid, tree.last_revision())
2631
623
        self.assertEqual(revid, base_branch.revid)
820
        self.assertEqual(revid, base_branch.revid)
2632
624
821
2633
822
    def test_error_on_merge_revspec(self):
2634
823
        # See bug 416950
2635
824
        source = self.make_branch_and_tree("source")
2636
825
        revid = source.commit("one")
2637
826
        base_branch = BaseRecipeBranch("source", "1", 0.2)
2638
827
        merged_branch = RecipeBranch("merged", "source", revspec="debian")
2639
828
        base_branch.merge_branch(merged_branch)
2640
829
        e = self.assertRaises(errors.InvalidRevisionSpec,
2641
830
                build_tree, base_branch, "target")
2642
831
        self.assertTrue(str(e).startswith("Requested revision: 'debian' "
2643
832
                    "does not exist in branch: "))
2644
833
        self.assertTrue(str(e).endswith(". Did you not mean to specify a "
2645
834
                    "revspec at the end of the merge line?"))
2646
835
2647
625
836
2648
626
class ResolveRevisionsTests(TestCaseWithTransport):
837
class ResolveRevisionsTests(TestCaseWithTransport):
2649
627
838
2650
@@ -704,7 +915,7 @@
2651
704
915
2652
705
    def test_changed_command(self):
916
    def test_changed_command(self):
2653
706
        source =self.make_branch_and_tree("source")
917
        source =self.make_branch_and_tree("source")
2655
707
        revid = source.commit("one")
918
        source.commit("one")
2656
708
        branch1 = BaseRecipeBranch("source", "{revno}", 0.2)
919
        branch1 = BaseRecipeBranch("source", "{revno}", 0.2)
2657
709
        branch2 = BaseRecipeBranch("source", "{revno}", 0.2)
920
        branch2 = BaseRecipeBranch("source", "{revno}", 0.2)
2658
710
        branch1.run_command("touch test1")
921
        branch1.run_command("touch test1")
2659
@@ -713,6 +924,17 @@
2660
713
                    if_changed_from=branch2))
924
                    if_changed_from=branch2))
2661
714
        self.assertEqual("source", branch1.url)
925
        self.assertEqual("source", branch1.url)
2662
715
926
2663
927
    def test_unchanged_command(self):
2664
928
        source =self.make_branch_and_tree("source")
2665
929
        source.commit("one")
2666
930
        branch1 = BaseRecipeBranch("source", "{revno}", 0.2)
2667
931
        branch2 = BaseRecipeBranch("source", "{revno}", 0.2)
2668
932
        branch1.run_command("touch test1")
2669
933
        branch2.run_command("touch test1")
2670
934
        self.assertEqual(False, resolve_revisions(branch1,
2671
935
                    if_changed_from=branch2))
2672
936
        self.assertEqual("source", branch1.url)
2673
937
2674
716
    def test_substitute(self):
938
    def test_substitute(self):
2675
717
        source =self.make_branch_and_tree("source")
939
        source =self.make_branch_and_tree("source")
2676
718
        revid1 = source.commit("one")
940
        revid1 = source.commit("one")
2677
@@ -737,13 +959,20 @@
2678
737
        resolve_revisions(branch1)
959
        resolve_revisions(branch1)
2679
738
        self.assertEqual("{debupstream}-2", branch1.deb_version)
960
        self.assertEqual("{debupstream}-2", branch1.deb_version)
2680
739
961
2683
740
962
    def test_subsitute_not_fully_expanded(self):
2684
741
class BuildManifestTests(TestCaseInTempDir):
963
        source =self.make_branch_and_tree("source")
2685
964
        source.commit("one")
2686
965
        source.commit("two")
2687
966
        branch1 = BaseRecipeBranch("source", "{revno:packaging}", 0.2)
2688
967
        self.assertRaises(errors.BzrCommandError, resolve_revisions, branch1)
2689
968
2690
969
2691
970
class StringifyTests(TestCaseInTempDir):
2692
742
971
2693
743
    def test_simple_manifest(self):
972
    def test_simple_manifest(self):
2694
744
        base_branch = BaseRecipeBranch("base_url", "1", 0.1)
973
        base_branch = BaseRecipeBranch("base_url", "1", 0.1)
2695
745
        base_branch.revid = "base_revid"
974
        base_branch.revid = "base_revid"
2697
746
        manifest = build_manifest(base_branch)
975
        manifest = str(base_branch)
2698
747
        self.assertEqual("# bzr-builder format 0.1 deb-version 1\n"
976
        self.assertEqual("# bzr-builder format 0.1 deb-version 1\n"
2699
748
                "base_url revid:base_revid\n", manifest)
977
                "base_url revid:base_revid\n", manifest)
2700
749
978
2701
@@ -759,7 +988,7 @@
2702
759
        merged_branch = RecipeBranch("merged", "merged_url")
988
        merged_branch = RecipeBranch("merged", "merged_url")
2703
760
        merged_branch.revid = "merged_revid"
989
        merged_branch.revid = "merged_revid"
2704
761
        base_branch.merge_branch(merged_branch)
990
        base_branch.merge_branch(merged_branch)
2706
762
        manifest = build_manifest(base_branch)
991
        manifest = str(base_branch)
2707
763
        self.assertEqual("# bzr-builder format 0.2 deb-version 2\n"
992
        self.assertEqual("# bzr-builder format 0.2 deb-version 2\n"
2708
764
                "base_url revid:base_revid\n"
993
                "base_url revid:base_revid\n"
2709
765
                "nest nested1 nested1_url nested revid:nested1_revid\n"
994
                "nest nested1 nested1_url nested revid:nested1_revid\n"
2710
@@ -770,11 +999,40 @@
2711
770
        base_branch = BaseRecipeBranch("base_url", "1", 0.2)
999
        base_branch = BaseRecipeBranch("base_url", "1", 0.2)
2712
771
        base_branch.revid = "base_revid"
1000
        base_branch.revid = "base_revid"
2713
772
        base_branch.run_command("touch test")
1001
        base_branch.run_command("touch test")
2715
773
        manifest = build_manifest(base_branch)
1002
        manifest = str(base_branch)
2716
774
        self.assertEqual("# bzr-builder format 0.2 deb-version 1\n"
1003
        self.assertEqual("# bzr-builder format 0.2 deb-version 1\n"
2717
775
                "base_url revid:base_revid\n"
1004
                "base_url revid:base_revid\n"
2718
776
                "run touch test\n", manifest)
1005
                "run touch test\n", manifest)
2719
777
1006
2720
1007
    def test_recipe_with_no_revspec(self):
2721
1008
        base_branch = BaseRecipeBranch("base_url", "1", 0.1)
2722
1009
        manifest = str(base_branch)
2723
1010
        self.assertEqual("# bzr-builder format 0.1 deb-version 1\n"
2724
1011
                "base_url\n", manifest)
2725
1012
2726
1013
    def test_recipe_with_tag_revspec(self):
2727
1014
        base_branch = BaseRecipeBranch("base_url", "1", 0.1,
2728
1015
                revspec="tag:foo")
2729
1016
        manifest = str(base_branch)
2730
1017
        self.assertEqual("# bzr-builder format 0.1 deb-version 1\n"
2731
1018
                "base_url tag:foo\n", manifest)
2732
1019
2733
1020
    def test_recipe_with_child(self):
2734
1021
        base_branch = BaseRecipeBranch("base_url", "2", 0.2)
2735
1022
        nested_branch1 = RecipeBranch("nested1", "nested1_url",
2736
1023
                revspec="tag:foo")
2737
1024
        base_branch.nest_branch("nested", nested_branch1)
2738
1025
        nested_branch2 = RecipeBranch("nested2", "nested2_url")
2739
1026
        nested_branch1.nest_branch("nested2", nested_branch2)
2740
1027
        merged_branch = RecipeBranch("merged", "merged_url")
2741
1028
        base_branch.merge_branch(merged_branch)
2742
1029
        manifest = str(base_branch)
2743
1030
        self.assertEqual("# bzr-builder format 0.2 deb-version 2\n"
2744
1031
                "base_url\n"
2745
1032
                "nest nested1 nested1_url nested tag:foo\n"
2746
1033
                "  nest nested2 nested2_url nested2\n"
2747
1034
                "merge merged merged_url\n", manifest)
2748
1035
2749
778
1036
2750
779
class RecipeBranchTests(TestCaseInTempDir):
1037
class RecipeBranchTests(TestCaseInTempDir):
2751
780
1038
2752
@@ -817,6 +1075,14 @@
2753
817
        base_branch.substitute_time(time)
1075
        base_branch.substitute_time(time)
2754
818
        self.assertEqual("1-197001010000", base_branch.deb_version)
1076
        self.assertEqual("1-197001010000", base_branch.deb_version)
2755
819
1077
2756
1078
    def test_substitute_date(self):
2757
1079
        time = datetime.datetime.utcfromtimestamp(1)
2758
1080
        base_branch = BaseRecipeBranch("base_url", "1-{date}", 0.2)
2759
1081
        base_branch.substitute_time(time)
2760
1082
        self.assertEqual("1-19700101", base_branch.deb_version)
2761
1083
        base_branch.substitute_time(time)
2762
1084
        self.assertEqual("1-19700101", base_branch.deb_version)
2763
1085
2764
820
    def test_substitute_revno(self):
1086
    def test_substitute_revno(self):
2765
821
        base_branch = BaseRecipeBranch("base_url", "1", 0.2)
1087
        base_branch = BaseRecipeBranch("base_url", "1", 0.2)
2766
822
        base_branch.substitute_revno(None, None)
1088
        base_branch.substitute_revno(None, None)
2767
@@ -838,3 +1104,17 @@
2768
838
        self.assertEqual("3", base_branch.deb_version)
1104
        self.assertEqual("3", base_branch.deb_version)
2769
839
        base_branch.substitute_revno("foo", lambda: "3")
1105
        base_branch.substitute_revno("foo", lambda: "3")
2770
840
        self.assertEqual("3", base_branch.deb_version)
1106
        self.assertEqual("3", base_branch.deb_version)
2771
1107
2772
1108
    def test_list_branch_names(self):
2773
1109
        base_branch = BaseRecipeBranch("base_url", "1", 0.2)
2774
1110
        base_branch.merge_branch(RecipeBranch("merged", "merged_url"))
2775
1111
        nested_branch = RecipeBranch("nested", "nested_url")
2776
1112
        nested_branch.merge_branch(
2777
1113
            RecipeBranch("merged_into_nested", "another_url"))
2778
1114
        base_branch.nest_branch("subdir", nested_branch)
2779
1115
        base_branch.merge_branch(
2780
1116
            RecipeBranch("another_nested", "yet_another_url"))
2781
1117
        base_branch.run_command("a command")
2782
1118
        self.assertEqual(
2783
1119
            ["merged", "nested", "merged_into_nested", "another_nested"],
2784
1120
            base_branch.list_branch_names())
Reviewer	Date Requested	Status
Andrew Bennetts (community)		Disapprove on 2010-07-29
James Westby	2009-11-18	Needs Fixing on 2010-07-08
Review via email: mp+14979@code.launchpad.net