view enterprise/kdei18n.py @ 39:17756cdce844

Make defining a status class easier with a meta class
author Bernhard Herzog <bh@intevation.de>
date Thu, 15 Mar 2007 13:00:01 +0100
parents f7f89548a2a6
children 3e610233ccfe 78cf5f6778ec
line wrap: on
line source
# Copyright (C) 2007 by Intevation GmbH
# Authors:
# Bernhard Herzog <bh@intevation.de>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

import os
import logging
import shutil
import time

import treepkg.packager
import treepkg.util
import treepkg.run as run


class SourcePackager(treepkg.packager.SourcePackager):

    """Creates the debian source package for the i18n files

    This is quite complicated.  The orig.tar.gz file of the debian
    source package contains one .tar.bz2 file for every language.  Those
    .tar.bz files are the kde-18n-<lang> files released by the KDE
    project.  For now, we only have the German localization in the
    enterprise source package, so the orig.tar.gz file will have the
    following contents:

      kde-i18n-<version>/
      kde-i18n-<version>/kde-i18n-de-<version>.tar.bz2

    <version> is the same everywhere.

    The kde-i18n-de tarball contains the localization files for the
    entire KDE project, including KDE-PIM.  The SVN enterprise branch
    only contains the localizations for KDE-PIM, though, so we have to
    assemble a new .tar.bz2 from an original
    kde-i18n-de-<version>.tar.bz and the new files from the enterprise
    branch.
    """

    pkg_basename = "kde-i18n"

    def determine_package_version(self, directory):
        enterprise_version = (time.strftime("%Y%m%d", time.localtime()) \
                              + "." + str(self.revision))
        kdepimversion = "3.5.5"
        version_template = "%(kdepimversion)s.enterprise.0.%(enterprise_version)s"
        return version_template % locals()

    def unpack_orig_tarball(self):
        orig_tarball = self.pkg_line.orig_tarball
        run.call(["tar", "xjf", orig_tarball, "-C", self.work_dir])
        tarbasename = os.path.basename(orig_tarball)
        splitext = os.path.splitext
        return os.path.join(self.work_dir,
                            splitext(splitext(tarbasename)[0])[0])

    def create_i18n_de_tarball(self, pkgbasedir, pkgbaseversion):
        """Creates a new kde-i18n-de tarball and returns its filename

        This is the tarball as it would be released by KDE.  It is not
        yet the tarball that will become the .orig.tar.gz for the debian
        package.
        """
        logging.info("Creating kde-i18n-de tarball")
        untarred_dir = self.unpack_orig_tarball()
        new_de_dir = os.path.join(pkgbasedir, "new-de")
        de_dir = os.path.join(pkgbasedir, "de")
        os.rename(de_dir, new_de_dir)
        treepkg.util.copytree(untarred_dir, de_dir)
        treepkg.util.copytree(new_de_dir, de_dir)
        logging.info("Running scripts/autogen.sh for kde-i18n-de tarball")
        run.call(["/bin/sh", "scripts/autogen.sh", "de"], cwd=pkgbasedir,
                 suppress_output=True)

        tarballdir = "kde-i18n-de-" + pkgbaseversion
        os.rename(de_dir, os.path.join(pkgbasedir, tarballdir))

        tarball = os.path.join(os.path.dirname(pkgbasedir),
                               tarballdir + ".tar.bz2")
        run.call(["tar", "cjf", tarball, "-C", pkgbasedir, tarballdir])
        logging.info("Created kde-i18n-de tarball")
        return tarball

    def do_package(self):
        # Create a new kde-i18n-de tarball from current SVN and the base
        # kde-i18n-de tarball.
        pkgbaseversion, pkgbasedir = self.export_sources()
        tarball = self.create_i18n_de_tarball(pkgbasedir, pkgbaseversion)

        # We have to reuse the same directory when building the
        # orig.tar.gz.  However, we need to preserver the scripts
        # sub-directory because it's not needed for the kde-i18n-de
        # tarball but for the .orig.tar.gz.
        pkg_scripts_dir = os.path.join(pkgbasedir, "scripts")
        tmp_scripts_dir = os.path.join(self.work_dir, "scripts")
        os.rename(pkg_scripts_dir, tmp_scripts_dir)
        shutil.rmtree(pkgbasedir)
        os.mkdir(pkgbasedir)
        os.rename(tmp_scripts_dir, pkg_scripts_dir)

        pkgbasename = self.pkg_basename + "_" + pkgbaseversion
        origtargz = os.path.join(self.work_dir,
                                 pkgbasename + ".orig.tar.gz")
        os.rename(tarball, os.path.join(pkgbasedir,
                                        os.path.basename(tarball)))
        self.create_tarball(origtargz, self.work_dir,
                            os.path.basename(pkgbasedir))

        changemsg = ("Update to SVN enterprise branch rev. %d"
                     % (self.revision,))
        self.copy_debian_directory(pkgbasedir, pkgbaseversion,
                                   changemsg)

        self.create_source_package(pkgbasedir, origtargz)
        self.move_source_package(pkgbasename)


class RevisionPackager(treepkg.packager.RevisionPackager):

    source_packager_cls = SourcePackager


class PackageLine(treepkg.packager.PackageLine):

    revision_packager_cls = RevisionPackager

    svn_external_subdirs = ["scripts", "scripts/admin"]

    extra_config_desc = ["orig_tarball"]

    def __init__(self, *args, **kw):
        self.orig_tarball = kw.pop("orig_tarball")
        super(PackageLine, self).__init__(*args, **kw)
This site is hosted by Intevation GmbH (Datenschutzerklärung und Impressum | Privacy Policy and Imprint)