#!/usr/bin/env python

"""buildpkg.py -- Build OS X packages for Apple's Installer.app.

This is an experimental command-line tool for building packages to be

installed with the Mac OS X Installer.app application.

It is much inspired by Apple's GUI tool called PackageMaker.app, that

seems to be part of the OS X developer tools installed in the folder

/Developer/Applications. But apparently there are other free tools to

do the same thing which are also named PackageMaker like Brian Hill's

one:

  http://personalpages.tds.net/~brian_hill/packagemaker.html

Beware of the multi-package features of Installer.app (which are not

yet supported here) that can potentially screw-up your installation

and are discussed in these articles on Stepwise:

  http://www.stepwise.com/Articles/Technical/Packages/InstallerWoes.html

  http://www.stepwise.com/Articles/Technical/Packages/InstallerOnX.html

Beside using the PackageMaker class directly, by importing it inside

another module, say, there are additional ways of using this module:

the top-level buildPackage() function provides a shortcut to the same

feature and is also called when using this module from the command-

line.

    ****************************************************************

    NOTE: For now you should be able to run this even on a non-OS X

          system and get something similar to a package, but without

          the real archive (needs pax) and bom files (needs mkbom)

          inside! This is only for providing a chance for testing to

          folks without OS X.

    ****************************************************************

TODO:

  - test pre-process and post-process scripts (Python ones?)

  - handle multi-volume packages (?)

  - integrate into distutils (?)

Dinu C. Gherman,

gherman@europemail.com

November 2001

!! USE AT YOUR OWN RISK !!

"""

__version__ = 0.2

__license__ = "FreeBSD"

import os, sys, glob, fnmatch, shutil, string, copy, getopt

from os.path import basename, dirname, join, islink, isdir, isfile

Error = "buildpkg.Error"

PKG_INFO_FIELDS = """\

Title

Version

Description

DefaultLocation

DeleteWarning

NeedsAuthorization

DisableStop

UseUserMask

Application

Relocatable

Required

InstallOnly

RequiresReboot

RootVolumeOnly

LongFilenames

LibrarySubdirectory

AllowBackRev

OverwritePermissions

InstallFat\

"""

######################################################################

# Helpers

######################################################################

# Convenience class, as suggested by /F.

class GlobDirectoryWalker:

    "A forward iterator that traverses files in a directory tree."

    def __init__(self, directory, pattern="*"):

        self.stack = [directory]

        self.pattern = pattern

        self.files = []

        self.index = 0

    def __getitem__(self, index):

        while 1:

            try:

                file = self.files[self.index]

                self.index = self.index + 1

            except IndexError:

                # pop next directory from stack

                self.directory = self.stack.pop()

                self.files = os.listdir(self.directory)

                self.index = 0

            else:

                # got a filename

                fullname = join(self.directory, file)

                if isdir(fullname) and not islink(fullname):

                    self.stack.append(fullname)

                if fnmatch.fnmatch(file, self.pattern):

                    return fullname

######################################################################

# The real thing

######################################################################

class PackageMaker:

    """A class to generate packages for Mac OS X.

    This is intended to create OS X packages (with extension .pkg)

    containing archives of arbitrary files that the Installer.app

    will be able to handle.

    As of now, PackageMaker instances need to be created with the

    title, version and description of the package to be built.

    The package is built after calling the instance method

    build(root, **options). It has the same name as the constructor's

    title argument plus a '.pkg' extension and is located in the same

    parent folder that contains the root folder.

    E.g. this will create a package folder /my/space/distutils.pkg/:

      pm = PackageMaker("distutils", "1.0.2", "Python distutils.")

      pm.build("/my/space/distutils")

    """

    packageInfoDefaults = {

        'Title': None,

        'Version': None,

        'Description': '',

        'DefaultLocation': '/',

        'DeleteWarning': '',

        'NeedsAuthorization': 'NO',

        'DisableStop': 'NO',

        'UseUserMask': 'YES',

        'Application': 'NO',

        'Relocatable': 'YES',

        'Required': 'NO',

        'InstallOnly': 'NO',

        'RequiresReboot': 'NO',

        'RootVolumeOnly' : 'NO',

        'InstallFat': 'NO',

        'LongFilenames': 'YES',

        'LibrarySubdirectory': 'Standard',

        'AllowBackRev': 'YES',

        'OverwritePermissions': 'NO',

        }

    def __init__(self, title, version, desc):

        "Init. with mandatory title/version/description arguments."

        info = {"Title": title, "Version": version, "Description": desc}

        self.packageInfo = copy.deepcopy(self.packageInfoDefaults)

        self.packageInfo.update(info)

        # variables set later

        self.packageRootFolder = None

        self.packageResourceFolder = None

        self.sourceFolder = None

        self.resourceFolder = None

    def build(self, root, resources=None, **options):

        """Create a package for some given root folder.

        With no 'resources' argument set it is assumed to be the same

        as the root directory. Option items replace the default ones

        in the package info.

        """

        # set folder attributes

        self.sourceFolder = root

        if resources is None:

            self.resourceFolder = root

        else:

            self.resourceFolder = resources

        # replace default option settings with user ones if provided

        fields = self. packageInfoDefaults.keys()

        for k, v in options.items():

            if k in fields:

                self.packageInfo[k] = v

            elif not k in ["OutputDir"]:

                raise Error, "Unknown package option: %s" % k

        # Check where we should leave the output. Default is current directory

        outputdir = options.get("OutputDir", os.getcwd())

        packageName = self.packageInfo["Title"]

        self.PackageRootFolder = os.path.join(outputdir, packageName + ".pkg")

        # do what needs to be done

        self._makeFolders()

        self._addInfo()

        self._addBom()

        self._addArchive()

        self._addResources()

        self._addSizes()

        self._addLoc()

    def _makeFolders(self):

        "Create package folder structure."

        # Not sure if the package name should contain the version or not...

        # packageName = "%s-%s" % (self.packageInfo["Title"],

        #                          self.packageInfo["Version"]) # ??

        contFolder = join(self.PackageRootFolder, "Contents")

        self.packageResourceFolder = join(contFolder, "Resources")

        os.mkdir(self.PackageRootFolder)

        os.mkdir(contFolder)

        os.mkdir(self.packageResourceFolder)

    def _addInfo(self):

        "Write .info file containing installing options."

        # Not sure if options in PKG_INFO_FIELDS are complete...

        info = ""

        for f in string.split(PKG_INFO_FIELDS, "\n"):

            if self.packageInfo.has_key(f):

                info = info + "%s %%(%s)s\n" % (f, f)

        info = info % self.packageInfo

        base = self.packageInfo["Title"] + ".info"

        path = join(self.packageResourceFolder, base)

        f = open(path, "w")

        f.write(info)

    def _addBom(self):

        "Write .bom file containing 'Bill of Materials'."

        # Currently ignores if the 'mkbom' tool is not available.

        try:

            base = self.packageInfo["Title"] + ".bom"

            bomPath = join(self.packageResourceFolder, base)

            cmd = "mkbom %s %s" % (self.sourceFolder, bomPath)

            res = os.system(cmd)

        except:

            pass

    def _addArchive(self):

        "Write .pax.gz file, a compressed archive using pax/gzip."

        # Currently ignores if the 'pax' tool is not available.

        cwd = os.getcwd()

        # create archive

        os.chdir(self.sourceFolder)

        base = basename(self.packageInfo["Title"]) + ".pax"

        self.archPath = join(self.packageResourceFolder, base)

        cmd = "pax -w -f %s %s" % (self.archPath, ".")

        res = os.system(cmd)

        # compress archive

        cmd = "gzip %s" % self.archPath

        res = os.system(cmd)

        os.chdir(cwd)

    def _addResources(self):

        "Add Welcome/ReadMe/License files, .lproj folders and scripts."

        # Currently we just copy everything that matches the allowed

        # filenames. So, it's left to Installer.app to deal with the

        # same file available in multiple formats...

        if not self.resourceFolder:

            return

        # find candidate resource files (txt html rtf rtfd/ or lproj/)

        allFiles = []

        for pat in string.split("*.txt *.html *.rtf *.rtfd *.lproj", " "):

            pattern = join(self.resourceFolder, pat)

            allFiles = allFiles + glob.glob(pattern)

        # find pre-process and post-process scripts

        # naming convention: packageName.{pre,post}_{upgrade,install}

        # Alternatively the filenames can be {pre,post}_{upgrade,install}

        # in which case we prepend the package name

        packageName = self.packageInfo["Title"]

        for pat in ("*upgrade", "*install", "*flight"):

            pattern = join(self.resourceFolder, packageName + pat)

            pattern2 = join(self.resourceFolder, pat)

            allFiles = allFiles + glob.glob(pattern)

            allFiles = allFiles + glob.glob(pattern2)

        # check name patterns

        files = []

        for f in allFiles:

            for s in ("Welcome", "License", "ReadMe"):

                if string.find(basename(f), s) == 0:

                    files.append((f, f))

            if f[-6:] == ".lproj":

                files.append((f, f))

            elif basename(f) in ["pre_upgrade", "pre_install", "post_upgrade", "post_install"]:

                files.append((f, packageName+"."+basename(f)))

            elif basename(f) in ["preflight", "postflight"]:

                files.append((f, f))

            elif f[-8:] == "_upgrade":

                files.append((f,f))

            elif f[-8:] == "_install":

                files.append((f,f))

        # copy files

        for src, dst in files:

            src = basename(src)

            dst = basename(dst)

            f = join(self.resourceFolder, src)

            if isfile(f):

                shutil.copy(f, os.path.join(self.packageResourceFolder, dst))

            elif isdir(f):

                # special case for .rtfd and .lproj folders...

                d = join(self.packageResourceFolder, dst)

                os.mkdir(d)

                files = GlobDirectoryWalker(f)

                for file in files:

                    shutil.copy(file, d)

    def _addSizes(self):

        "Write .sizes file with info about number and size of files."

        # Not sure if this is correct, but 'installedSize' and

        # 'zippedSize' are now in Bytes. Maybe blocks are needed?

        # Well, Installer.app doesn't seem to care anyway, saying

        # the installation needs 100+ MB...

        numFiles = 0

        installedSize = 0

        zippedSize = 0

        files = GlobDirectoryWalker(self.sourceFolder)

        for f in files:

            numFiles = numFiles + 1

            installedSize = installedSize + os.lstat(f)[6]

        try:

            zippedSize = os.stat(self.archPath+ ".gz")[6]

        except OSError: # ignore error

            pass

        base = self.packageInfo["Title"] + ".sizes"

        f = open(join(self.packageResourceFolder, base), "w")

        format = "NumFiles %d\nInstalledSize %d\nCompressedSize %d\n"

        f.write(format % (numFiles, installedSize, zippedSize))

    def _addLoc(self):

        "Write .loc file."

        base = self.packageInfo["Title"] + ".loc"

        f = open(join(self.packageResourceFolder, base), "w")

        f.write('/')

# Shortcut function interface

def buildPackage(*args, **options):

    "A Shortcut function for building a package."

    o = options

    title, version, desc = o["Title"], o["Version"], o["Description"]

    pm = PackageMaker(title, version, desc)

    apply(pm.build, list(args), options)

######################################################################

# Tests

######################################################################

def test0():

    "Vanilla test for the distutils distribution."

    pm = PackageMaker("distutils2", "1.0.2", "Python distutils package.")

    pm.build("/Users/dinu/Desktop/distutils2")

def test1():

    "Test for the reportlab distribution with modified options."

    pm = PackageMaker("reportlab", "1.10",

                      "ReportLab's Open Source PDF toolkit.")

    pm.build(root="/Users/dinu/Desktop/reportlab",

             DefaultLocation="/Applications/ReportLab",

             Relocatable="YES")

def test2():

    "Shortcut test for the reportlab distribution with modified options."

    buildPackage(

        "/Users/dinu/Desktop/reportlab",

        Title="reportlab",

        Version="1.10",

        Description="ReportLab's Open Source PDF toolkit.",

        DefaultLocation="/Applications/ReportLab",

        Relocatable="YES")

######################################################################

# Command-line interface

######################################################################

def printUsage():

    "Print usage message."

    format = "Usage: %s <opts1> [<opts2>] <root> [<resources>]"

    print format % basename(sys.argv[0])

    print

    print "       with arguments:"

    print "           (mandatory) root:         the package root folder"

    print "           (optional)  resources:    the package resources folder"

    print

    print "       and options:"

    print "           (mandatory) opts1:"

    mandatoryKeys = string.split("Title Version Description", " ")

    for k in mandatoryKeys:

        print "               --%s" % k

    print "           (optional) opts2: (with default values)"

    pmDefaults = PackageMaker.packageInfoDefaults

    optionalKeys = pmDefaults.keys()

    for k in mandatoryKeys:

        optionalKeys.remove(k)

    optionalKeys.sort()

    maxKeyLen = max(map(len, optionalKeys))

    for k in optionalKeys:

        format = "               --%%s:%s %%s"

        format = format % (" " * (maxKeyLen-len(k)))

        print format % (k, repr(pmDefaults[k]))

def main():

    "Command-line interface."

    shortOpts = ""

    keys = PackageMaker.packageInfoDefaults.keys()

    longOpts = map(lambda k: k+"=", keys)

    try:

        opts, args = getopt.getopt(sys.argv[1:], shortOpts, longOpts)

    except getopt.GetoptError, details:

        print details

        printUsage()

        return

    optsDict = {}

    for k, v in opts:

        optsDict[k[2:]] = v

    ok = optsDict.keys()

    if not (1 <= len(args) <= 2):

        print "No argument given!"

    elif not ("Title" in ok and \

              "Version" in ok and \

              "Description" in ok):

        print "Missing mandatory option!"

    else:

        apply(buildPackage, args, optsDict)

        return

    printUsage()

    # sample use:

    # buildpkg.py --Title=distutils \

    #             --Version=1.0.2 \

    #             --Description="Python distutils package." \

    #             /Users/dinu/Desktop/distutils

if __name__ == "__main__":

    main()