#! /usr/bin/env python

"""\

bundlebuilder.py -- Tools to assemble MacOS X (application) bundles.

This module contains two classes to build so called "bundles" for

MacOS X. BundleBuilder is a general tool, AppBuilder is a subclass

specialized in building application bundles.

[Bundle|App]Builder objects are instantiated with a bunch of keyword

arguments, and have a build() method that will do all the work. See

the class doc strings for a description of the constructor arguments.

The module contains a main program that can be used in two ways:

  % python bundlebuilder.py [options] build

  % python buildapp.py [options] build

Where "buildapp.py" is a user-supplied setup.py-like script following

this model:

  from bundlebuilder import buildapp

  buildapp(<lots-of-keyword-args>)

"""

__all__ = ["BundleBuilder", "BundleBuilderError", "AppBuilder", "buildapp"]

from warnings import warnpy3k

warnpy3k("In 3.x, the bundlebuilder module is removed.", stacklevel=2)

import sys

import os, errno, shutil

import imp, marshal

import re

from copy import deepcopy

import getopt

from plistlib import Plist

from types import FunctionType as function

class BundleBuilderError(Exception): pass

class Defaults:

    """Class attributes that don't start with an underscore and are

    not functions or classmethods are (deep)copied to self.__dict__.

    This allows for mutable default values.

    """

    def __init__(self, **kwargs):

        defaults = self._getDefaults()

        defaults.update(kwargs)

        self.__dict__.update(defaults)

    def _getDefaults(cls):

        defaults = {}

        for base in cls.__bases__:

            if hasattr(base, "_getDefaults"):

                defaults.update(base._getDefaults())

        for name, value in cls.__dict__.items():

            if name[0] != "_" and not isinstance(value,

                    (function, classmethod)):

                defaults[name] = deepcopy(value)

        return defaults

    _getDefaults = classmethod(_getDefaults)

class BundleBuilder(Defaults):

    """BundleBuilder is a barebones class for assembling bundles. It

    knows nothing about executables or icons, it only copies files

    and creates the PkgInfo and Info.plist files.

    """

    # (Note that Defaults.__init__ (deep)copies these values to

    # instance variables. Mutable defaults are therefore safe.)

    # Name of the bundle, with or without extension.

    name = None

    # The property list ("plist")

    plist = Plist(CFBundleDevelopmentRegion = "English",

                  CFBundleInfoDictionaryVersion = "6.0")

    # The type of the bundle.

    type = "BNDL"

    # The creator code of the bundle.

    creator = None

    # the CFBundleIdentifier (this is used for the preferences file name)

    bundle_id = None

    # List of files that have to be copied to <bundle>/Contents/Resources.

    resources = []

    # List of (src, dest) tuples; dest should be a path relative to the bundle

    # (eg. "Contents/Resources/MyStuff/SomeFile.ext).

    files = []

    # List of shared libraries (dylibs, Frameworks) to bundle with the app

    # will be placed in Contents/Frameworks

    libs = []

    # Directory where the bundle will be assembled.

    builddir = "build"

    # Make symlinks instead copying files. This is handy during debugging, but

    # makes the bundle non-distributable.

    symlink = 0

    # Verbosity level.

    verbosity = 1

    # Destination root directory

    destroot = ""

    def setup(self):

        # XXX rethink self.name munging, this is brittle.

        self.name, ext = os.path.splitext(self.name)

        if not ext:

            ext = ".bundle"

        bundleextension = ext

        # misc (derived) attributes

        self.bundlepath = pathjoin(self.builddir, self.name + bundleextension)

        plist = self.plist

        plist.CFBundleName = self.name

        plist.CFBundlePackageType = self.type

        if self.creator is None:

            if hasattr(plist, "CFBundleSignature"):

                self.creator = plist.CFBundleSignature

            else:

                self.creator = "????"

        plist.CFBundleSignature = self.creator

        if self.bundle_id:

            plist.CFBundleIdentifier = self.bundle_id

        elif not hasattr(plist, "CFBundleIdentifier"):

            plist.CFBundleIdentifier = self.name

    def build(self):

        """Build the bundle."""

        builddir = self.builddir

        if builddir and not os.path.exists(builddir):

            os.mkdir(builddir)

        self.message("Building %s" % repr(self.bundlepath), 1)

        if os.path.exists(self.bundlepath):

            shutil.rmtree(self.bundlepath)

        if os.path.exists(self.bundlepath + '~'):

            shutil.rmtree(self.bundlepath + '~')

        bp = self.bundlepath

        # Create the app bundle in a temporary location and then

        # rename the completed bundle. This way the Finder will

        # never see an incomplete bundle (where it might pick up

        # and cache the wrong meta data)

        self.bundlepath = bp + '~'

        try:

            os.mkdir(self.bundlepath)

            self.preProcess()

            self._copyFiles()

            self._addMetaFiles()

            self.postProcess()

            os.rename(self.bundlepath, bp)

        finally:

            self.bundlepath = bp

        self.message("Done.", 1)

    def preProcess(self):

        """Hook for subclasses."""

        pass

    def postProcess(self):

        """Hook for subclasses."""

        pass

    def _addMetaFiles(self):

        contents = pathjoin(self.bundlepath, "Contents")

        makedirs(contents)

        #

        # Write Contents/PkgInfo

        assert len(self.type) == len(self.creator) == 4, \

                "type and creator must be 4-byte strings."

        pkginfo = pathjoin(contents, "PkgInfo")

        f = open(pkginfo, "wb")

        f.write(self.type + self.creator)

        f.close()

        #

        # Write Contents/Info.plist

        infoplist = pathjoin(contents, "Info.plist")

        self.plist.write(infoplist)

    def _copyFiles(self):

        files = self.files[:]

        for path in self.resources:

            files.append((path, pathjoin("Contents", "Resources",

                os.path.basename(path))))

        for path in self.libs:

            files.append((path, pathjoin("Contents", "Frameworks",

                os.path.basename(path))))

        if self.symlink:

            self.message("Making symbolic links", 1)

            msg = "Making symlink from"

        else:

            self.message("Copying files", 1)

            msg = "Copying"

        files.sort()

        for src, dst in files:

            if os.path.isdir(src):

                self.message("%s %s/ to %s/" % (msg, src, dst), 2)

            else:

                self.message("%s %s to %s" % (msg, src, dst), 2)

            dst = pathjoin(self.bundlepath, dst)

            if self.symlink:

                symlink(src, dst, mkdirs=1)

            else:

                copy(src, dst, mkdirs=1)

    def message(self, msg, level=0):

        if level <= self.verbosity:

            indent = ""

            if level > 1:

                indent = (level - 1) * "  "

            sys.stderr.write(indent + msg + "\n")

    def report(self):

        # XXX something decent

        pass

if __debug__:

    PYC_EXT = ".pyc"

else:

    PYC_EXT = ".pyo"

MAGIC = imp.get_magic()

USE_ZIPIMPORT = "zipimport" in sys.builtin_module_names

# For standalone apps, we have our own minimal site.py. We don't need

# all the cruft of the real site.py.

SITE_PY = """\

import sys

if not %(semi_standalone)s:

    del sys.path[1:]  # sys.path[0] is Contents/Resources/

"""

if USE_ZIPIMPORT:

    ZIP_ARCHIVE = "Modules.zip"

    SITE_PY += "sys.path.append(sys.path[0] + '/%s')\n" % ZIP_ARCHIVE

    def getPycData(fullname, code, ispkg):

        if ispkg:

            fullname += ".__init__"

        path = fullname.replace(".", os.sep) + PYC_EXT

        return path, MAGIC + '\0\0\0\0' + marshal.dumps(code)

#

# Extension modules can't be in the modules zip archive, so a placeholder

# is added instead, that loads the extension from a specified location.

#

EXT_LOADER = """\

def __load():

    import imp, sys, os

    for p in sys.path:

        path = os.path.join(p, "%(filename)s")

        if os.path.exists(path):

            break

    else:

        assert 0, "file not found: %(filename)s"

    mod = imp.load_dynamic("%(name)s", path)

__load()

del __load

"""

MAYMISS_MODULES = ['mac', 'os2', 'nt', 'ntpath', 'dos', 'dospath',

    'win32api', 'ce', '_winreg', 'nturl2path', 'sitecustomize',

    'org.python.core', 'riscos', 'riscosenviron', 'riscospath'

]

STRIP_EXEC = "/usr/bin/strip"

#

# We're using a stock interpreter to run the app, yet we need

# a way to pass the Python main program to the interpreter. The

# bootstrapping script fires up the interpreter with the right

# arguments. os.execve() is used as OSX doesn't like us to

# start a real new process. Also, the executable name must match

# the CFBundleExecutable value in the Info.plist, so we lie

# deliberately with argv[0]. The actual Python executable is

# passed in an environment variable so we can "repair"

# sys.executable later.

#

BOOTSTRAP_SCRIPT = """\

#!%(hashbang)s

import sys, os

execdir = os.path.dirname(sys.argv[0])

executable = os.path.join(execdir, "%(executable)s")

resdir = os.path.join(os.path.dirname(execdir), "Resources")

libdir = os.path.join(os.path.dirname(execdir), "Frameworks")

mainprogram = os.path.join(resdir, "%(mainprogram)s")

sys.argv.insert(1, mainprogram)

if %(standalone)s or %(semi_standalone)s:

    os.environ["PYTHONPATH"] = resdir

    if %(standalone)s:

        os.environ["PYTHONHOME"] = resdir

else:

    pypath = os.getenv("PYTHONPATH", "")

    if pypath:

        pypath = ":" + pypath

    os.environ["PYTHONPATH"] = resdir + pypath

os.environ["PYTHONEXECUTABLE"] = executable

os.environ["DYLD_LIBRARY_PATH"] = libdir

os.environ["DYLD_FRAMEWORK_PATH"] = libdir

os.execve(executable, sys.argv, os.environ)

"""

#

# Optional wrapper that converts "dropped files" into sys.argv values.

#

ARGV_EMULATOR = """\

import argvemulator, os

argvemulator.ArgvCollector().mainloop()

execfile(os.path.join(os.path.split(__file__)[0], "%(realmainprogram)s"))

"""

#

# When building a standalone app with Python.framework, we need to copy

# a subset from Python.framework to the bundle. The following list

# specifies exactly what items we'll copy.

#

PYTHONFRAMEWORKGOODIES = [

    "Python",  # the Python core library

    "Resources/English.lproj",

    "Resources/Info.plist",

    "Resources/version.plist",

]

def isFramework():

    return sys.exec_prefix.find("Python.framework") > 0

LIB = os.path.join(sys.prefix, "lib", "python" + sys.version[:3])

SITE_PACKAGES = os.path.join(LIB, "site-packages")

class AppBuilder(BundleBuilder):

    # Override type of the bundle.

    type = "APPL"

    # platform, name of the subfolder of Contents that contains the executable.

    platform = "MacOS"

    # A Python main program. If this argument is given, the main

    # executable in the bundle will be a small wrapper that invokes

    # the main program. (XXX Discuss why.)

    mainprogram = None

    # The main executable. If a Python main program is specified

    # the executable will be copied to Resources and be invoked

    # by the wrapper program mentioned above. Otherwise it will

    # simply be used as the main executable.

    executable = None

    # The name of the main nib, for Cocoa apps. *Must* be specified

    # when building a Cocoa app.

    nibname = None

    # The name of the icon file to be copied to Resources and used for

    # the Finder icon.

    iconfile = None

    # Symlink the executable instead of copying it.

    symlink_exec = 0

    # If True, build standalone app.

    standalone = 0

    # If True, build semi-standalone app (only includes third-party modules).

    semi_standalone = 0

    # If set, use this for #! lines in stead of sys.executable

    python = None

    # If True, add a real main program that emulates sys.argv before calling

    # mainprogram

    argv_emulation = 0

    # The following attributes are only used when building a standalone app.

    # Exclude these modules.

    excludeModules = []

    # Include these modules.

    includeModules = []

    # Include these packages.

    includePackages = []

    # Strip binaries from debug info.

    strip = 0

    # Found Python modules: [(name, codeobject, ispkg), ...]

    pymodules = []

    # Modules that modulefinder couldn't find:

    missingModules = []

    maybeMissingModules = []

    def setup(self):

        if ((self.standalone or self.semi_standalone)

            and self.mainprogram is None):

            raise BundleBuilderError, ("must specify 'mainprogram' when "

                    "building a standalone application.")

        if self.mainprogram is None and self.executable is None:

            raise BundleBuilderError, ("must specify either or both of "

                    "'executable' and 'mainprogram'")

        self.execdir = pathjoin("Contents", self.platform)

        if self.name is not None:

            pass

        elif self.mainprogram is not None:

            self.name = os.path.splitext(os.path.basename(self.mainprogram))[0]

        elif executable is not None:

            self.name = os.path.splitext(os.path.basename(self.executable))[0]

        if self.name[-4:] != ".app":

            self.name += ".app"

        if self.executable is None:

            if not self.standalone and not isFramework():

                self.symlink_exec = 1

            if self.python:

                self.executable = self.python

            else:

                self.executable = sys.executable

        if self.nibname:

            self.plist.NSMainNibFile = self.nibname

            if not hasattr(self.plist, "NSPrincipalClass"):

                self.plist.NSPrincipalClass = "NSApplication"

        if self.standalone and isFramework():

            self.addPythonFramework()

        BundleBuilder.setup(self)

        self.plist.CFBundleExecutable = self.name

        if self.standalone or self.semi_standalone:

            self.findDependencies()

    def preProcess(self):

        resdir = "Contents/Resources"

        if self.executable is not None:

            if self.mainprogram is None:

                execname = self.name

            else:

                execname = os.path.basename(self.executable)

            execpath = pathjoin(self.execdir, execname)

            if not self.symlink_exec:

                self.files.append((self.destroot + self.executable, execpath))

            self.execpath = execpath

        if self.mainprogram is not None:

            mainprogram = os.path.basename(self.mainprogram)

            self.files.append((self.mainprogram, pathjoin(resdir, mainprogram)))

            if self.argv_emulation:

                # Change the main program, and create the helper main program (which

                # does argv collection and then calls the real main).

                # Also update the included modules (if we're creating a standalone

                # program) and the plist

                realmainprogram = mainprogram

                mainprogram = '__argvemulator_' + mainprogram

                resdirpath = pathjoin(self.bundlepath, resdir)

                mainprogrampath = pathjoin(resdirpath, mainprogram)

                makedirs(resdirpath)

                open(mainprogrampath, "w").write(ARGV_EMULATOR % locals())

                if self.standalone or self.semi_standalone:

                    self.includeModules.append("argvemulator")

                    self.includeModules.append("os")

                if not self.plist.has_key("CFBundleDocumentTypes"):

                    self.plist["CFBundleDocumentTypes"] = [

                        { "CFBundleTypeOSTypes" : [

                            "****",

                            "fold",

                            "disk"],

                          "CFBundleTypeRole": "Viewer"}]

            # Write bootstrap script

            executable = os.path.basename(self.executable)

            execdir = pathjoin(self.bundlepath, self.execdir)

            bootstrappath = pathjoin(execdir, self.name)

            makedirs(execdir)

            if self.standalone or self.semi_standalone:

                # XXX we're screwed when the end user has deleted

                # /usr/bin/python

                hashbang = "/usr/bin/python"

            elif self.python:

                hashbang = self.python

            else:

                hashbang = os.path.realpath(sys.executable)

            standalone = self.standalone

            semi_standalone = self.semi_standalone

            open(bootstrappath, "w").write(BOOTSTRAP_SCRIPT % locals())

            os.chmod(bootstrappath, 0775)

        if self.iconfile is not None:

            iconbase = os.path.basename(self.iconfile)

            self.plist.CFBundleIconFile = iconbase

            self.files.append((self.iconfile, pathjoin(resdir, iconbase)))

    def postProcess(self):

        if self.standalone or self.semi_standalone:

            self.addPythonModules()

        if self.strip and not self.symlink:

            self.stripBinaries()

        if self.symlink_exec and self.executable:

            self.message("Symlinking executable %s to %s" % (self.executable,

                    self.execpath), 2)

            dst = pathjoin(self.bundlepath, self.execpath)

            makedirs(os.path.dirname(dst))

            os.symlink(os.path.abspath(self.executable), dst)