def create_debian_repository(self, log):
in_repo = cmd_env.PrefixCmdEnv(cmd_env.in_dir(self._repo_dir),
self._env)
dist = "dists/custom"
main = os.path.join(dist, "main")
# TODO: use linux32 as described in pbuilder docs
# arch_code = "i386"
arch_code = "amd64"
arch = os.path.join(main, "binary-%s" % arch_code)
in_repo.cmd(["mkdir", "-p", arch])
in_repo.cmd(["mkdir", "-p", os.path.join(main, "source")])
self._env.cmd(["cp", self._get_deb_path(),
os.path.join(self._repo_dir, arch)])
in_repo.cmd(cmd_env.write_file_cmd("apt-ftparchive.conf", """\
Dir {
ArchiveDir %(repo_dir)s;
CacheDir %(repo_dir)s;
};
BinDirectory "dists/custom/main/binary-%(arch_code)s" {
Packages "dists/custom/main/binary-%(arch_code)s/Packages";
Contents "dists/custom/Contents-%(arch_code)s";
SrcPackages "dists/custom/main/source/Sources";
};
Tree "dists/custom" {
Sections "main";
Architectures "%(arch_code)s source";
};
TreeDefault {
BinCacheDB "$(DIST)/packages-$(ARCH).db"
};
""" % dict(repo_dir=os.path.abspath(self._repo_dir),
arch_code=arch_code)))
in_repo.cmd(cmd_env.write_file_cmd("apt-custom-release.conf", """\
APT::FTPArchive::Release::Origin "testdeb";
APT::FTPArchive::Release::Label "testdeb";
APT::FTPArchive::Release::Suite "custom";
APT::FTPArchive::Release::Codename "custom";
APT::FTPArchive::Release::Architectures "%(arch_code)s source";
APT::FTPArchive::Release::Components "main";
APT::FTPArchive::Release::Description "Custom debian packages for testdeb";
""" % dict(arch_code=arch_code)))
OutputToGzipFileEnv(in_repo, os.path.join(arch, "Packages.gz")).cmd(
["apt-ftparchive",
"--db", os.path.join(dist, "packages-%s.db" % arch_code),
"packages", arch])
in_repo.cmd(["apt-ftparchive", "generate", "apt-ftparchive.conf"])
release.OutputToFileEnv(in_repo, os.path.join(dist, "Release")).cmd(
["apt-ftparchive", "--config-file", "apt-custom-release.conf",
"release", dist])
in_repo.cmd(["gpg", "--output", os.path.join(dist, "Release.gpg"),
"-ba", os.path.join(dist, "Release")])
def update_version(self, log):
version_path = "mechanize/_version.py"
template = """\
"%(text)s"
__version__ = %(tuple)s
"""
old_text = release.read_file_from_env(self._in_source_repo,
version_path)
old_version = old_text.splitlines()[0].strip(' "')
assert old_version == str(self._release_version), \
(old_version, str(self._release_version))
def version_text(version):
return template % {
"text": str(version),
"tuple": repr(tuple(version.tuple[:-1]))
}
assert old_text == version_text(release.parse_version(old_version)), \
(old_text, version_text(release.parse_version(old_version)))
self._in_source_repo.cmd(
cmd_env.write_file_cmd(
version_path,
version_text(self._release_version.next_version())))
self._in_source_repo.cmd(
["git", "commit", "-m", "Update version", version_path])
def setup_py_sdist(self, log):
self._in_repo.cmd(release.rm_rf_cmd("dist"))
# write empty setup.cfg so source distribution is built using a version
# number without ".dev" and today's date appended
self._in_repo.cmd(cmd_env.write_file_cmd("setup.cfg", ""))
self._in_repo.cmd(["python", "setup.py", "sdist",
"--formats=gztar,zip"])
archives = set(os.listdir(os.path.join(self._repo_path, "dist")))
assert archives == self._source_distributions, \
(archives, self._source_distributions)
def setup_py_sdist(self, log):
self._in_repo.cmd(release.rm_rf_cmd("dist"))
# write empty setup.cfg so source distribution is built using a version
# number without ".dev" and today's date appended
self._in_repo.cmd(cmd_env.write_file_cmd("setup.cfg", ""))
self._in_repo.cmd(["python", "setup.py", "sdist",
"--formats=gztar,zip"])
archives = set(os.listdir(os.path.join(self._repo_path, "dist")))
assert archives == self._source_distributions, \
(archives, self._source_distributions)
def test_backslash_escapes_are_not_interpreted(self):
filename = tempfile.mktemp()
try:
backslash_escaped = "\\r"
cmd = cmd_env.write_file_cmd(filename, backslash_escaped)
env = cmd_env.BasicEnv()
env.cmd(cmd)
self.assertEqual(cmd_env.read_file(filename), backslash_escaped)
finally:
os.remove(filename)
def write_test_wrapper(self, log):
self._in_test_dir.cmd(cmd_env.write_file_cmd(
"testrepo.list", """\
deb file://%s custom main
""" % os.path.abspath(self._repo_dir)))
release.OutputToFileEnv(self._in_test_dir, "key").cmd(
["gpg", "--export", "--armor", "A362A9D1"])
deb_name = os.path.basename(self._get_deb_path()).partition("_")[0]
self._in_test_dir.cmd(cmd_env.write_file_cmd(
"test.sh",
"""\
cp %(sources_list_file)s /etc/apt/sources.list.d
apt-key add %(key_file)s
apt-get update
apt-get install -y %(deb_name)s
exec "$@" > %(output_file)s
""" % dict(sources_list_file=os.path.join(self._test_dir, "testrepo.list"),
deb_name=pipes.quote(deb_name),
key_file=os.path.join(self._test_dir, "key"),
output_file=self._output_file)))
self._in_test_dir.cmd(["chmod", "+x", "test.sh"])
def set_up(self, env):
env.cmd(cmd_env.write_file_cmd(
"test.html",
"""\
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head><title>Title</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<p>Hello, valid world.
</body>
</html>
"""))
def submit_to_ppa(self, log):
dput_cf = os.path.join(self._release_dir, "dput.cf")
self._env.cmd(cmd_env.write_file_cmd(dput_cf, """\
[w3cvalidator]
fqdn = ppa.launchpad.net
method = ftp
incoming = ~jjl/w3cvalidator/ubuntu/
login = anonymous
allow_unsigned_uploads = 0
"""))
version = self._get_version_from_changelog()
changes = os.path.join(
self._repo_path, "..",
"w3c-markup-validator-commandline_%s_source.changes" % version)
print "changes %r" % changes
self._env.cmd(["dput", "--config", dput_cf, "w3cvalidator", changes])
def update_version(self, log):
version_path = "mechanize/_version.py"
template = """\
"%(text)s"
__version__ = %(tuple)s
"""
old_text = release.read_file_from_env(self._in_source_repo,
version_path)
old_version = old_text.splitlines()[0].strip(' "')
assert old_version == str(self._release_version), \
(old_version, str(self._release_version))
def version_text(version):
return template % {"text": str(version),
"tuple": repr(tuple(version.tuple[:-1]))}
assert old_text == version_text(release.parse_version(old_version)), \
(old_text, version_text(release.parse_version(old_version)))
self._in_source_repo.cmd(cmd_env.write_file_cmd(
version_path,
version_text(self._release_version.next_version())))
self._in_source_repo.cmd(["git", "commit", "-m", "Update version",
version_path])
def write_email(self, log):
log = release.get_cmd_stdout(self._in_repo,
["git", "log", '--pretty=format: * %s',
"%s..HEAD" % self._previous_version])
# filter out some uninteresting commits
log = "".join(line for line in log.splitlines(True) if not
re.match("^ \* Update (?:changelog|version)$", line,
re.I))
self._in_release_dir.cmd(cmd_env.write_file_cmd(
"announce_email.txt", u"""\
ANN: mechanize {version} released
http://wwwsearch.sourceforge.net/mechanize/
This is a stable bugfix release.
Changes since {previous_version}:
{log}
About mechanize
=============================================
Requires Python 2.4, 2.5, 2.6, or 2.7.
Stateful programmatic web browsing, after Andy Lester's Perl module
WWW::Mechanize.
Example:
import re
from mechanize import Browser
b = Browser()
b.open("http://www.example.com/")
# follow second link with element text matching regular expression
response = b.follow_link(text_regex=re.compile(r"cheese\s*shop"), nr=1)
b.select_form(name="order")
# Browser passes through unknown attributes (including methods)
# to the selected HTMLForm
b["cheeses"] = ["mozzarella", "caerphilly"] # (the method here is __setitem__)
response2 = b.submit() # submit current form
response3 = b.back() # back to cheese shop
response4 = b.reload()
for link in b.forms():
print form
# .links() optionally accepts the keyword args of .follow_/.find_link()
for link in b.links(url_regex=re.compile("python.org")):
print link
b.follow_link(link) # can be EITHER Link instance OR keyword args
b.back()
John
""".format(log=log,
version=self._release_version,
previous_version=self._previous_version)))
def write_email(self, log):
log = release.get_cmd_stdout(self._in_repo,
["git", "log", '--pretty=format: * %s',
"%s..HEAD" % self._previous_version])
# filter out some uninteresting commits
log = "".join(line for line in log.splitlines(True) if not
re.match("^ \* Update (?:changelog|version)$", line,
re.I))
self._in_release_dir.cmd(cmd_env.write_file_cmd(
"announce_email.txt", u"""\
ANN: mechanize {version} released
http://wwwsearch.sourceforge.net/mechanize/
This is a stable bugfix release.
Changes since {previous_version}:
{log}
About mechanize
=============================================
Requires Python 2.4, 2.5, 2.6, or 2.7.
Stateful programmatic web browsing, after Andy Lester's Perl module
WWW::Mechanize.
Example:
import re
from mechanize import Browser
b = Browser()
b.open("http://www.example.com/")
# follow second link with element text matching regular expression
response = b.follow_link(text_regex=re.compile(r"cheese\s*shop"), nr=1)
b.select_form(name="order")
# Browser passes through unknown attributes (including methods)
# to the selected HTMLForm
b["cheeses"] = ["mozzarella", "caerphilly"] # (the method here is __setitem__)
response2 = b.submit() # submit current form
response3 = b.back() # back to cheese shop
response4 = b.reload()
for link in b.forms():
print form
# .links() optionally accepts the keyword args of .follow_/.find_link()
for link in b.links(url_regex=re.compile("python.org")):
print link
b.follow_link(link) # can be EITHER Link instance OR keyword args
b.back()
John
""".format(log=log,
version=self._release_version,
previous_version=self._previous_version)))
def write_file_to_env(env, filename, data):
env.cmd(cmd_env.write_file_cmd(filename, data))
