| #! /usr/bin/env python |
| |
| """\ |
| bundlebuilder.py -- Tools to assemble MacOS X (application) bundles. |
| |
| This module contains three classes to build so called "bundles" for |
| MacOS X. BundleBuilder is a general tool, AppBuilder is a subclass |
| specialized in building application bundles. CocoaAppBuilder is a |
| further specialization of AppBuilder. |
| |
| [Bundle|App|CocoaApp]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. |
| |
| """ |
| |
| # |
| # XXX Todo: |
| # - a command line interface, also for use with the buildapp() and |
| # buildcocoaapp() convenience functions. |
| # - modulefinder support to build standalone apps |
| # |
| |
| __all__ = ["BundleBuilder", "AppBuilder", "CocoaAppBuilder", |
| "buildapp", "buildcocoaapp"] |
| |
| |
| import sys |
| import os, errno, shutil |
| from plistlib import Plist |
| |
| |
| plistDefaults = Plist( |
| CFBundleDevelopmentRegion = "English", |
| CFBundleInfoDictionaryVersion = "6.0", |
| ) |
| |
| |
| class BundleBuilder: |
| |
| """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. |
| |
| Constructor arguments: |
| |
| name: Name of the bundle, with or without extension. |
| plist: A plistlib.Plist object. |
| type: The type of the bundle. Defaults to "APPL". |
| creator: The creator code of the bundle. Defaults to "????". |
| resources: List of files that have to be copied to |
| <bundle>/Contents/Resources. Defaults to an empty list. |
| files: List of (src, dest) tuples; dest should be a path relative |
| to the bundle (eg. "Contents/Resources/MyStuff/SomeFile.ext. |
| Defaults to an empty list. |
| builddir: Directory where the bundle will be assembled. Defaults |
| to "build" (in the current directory). |
| symlink: Make symlinks instead copying files. This is handy during |
| debugging, but makes the bundle non-distributable. Defaults to |
| False. |
| verbosity: verbosity level, defaults to 1 |
| """ |
| |
| def __init__(self, name, plist=None, type="APPL", creator="????", |
| resources=None, files=None, builddir="build", platform="MacOS", |
| symlink=0, verbosity=1): |
| """See the class doc string for a description of the arguments.""" |
| self.name, ext = os.path.splitext(name) |
| if not ext: |
| ext = ".bundle" |
| self.bundleextension = ext |
| if plist is None: |
| plist = Plist() |
| self.plist = plist |
| self.type = type |
| self.creator = creator |
| if files is None: |
| files = [] |
| if resources is None: |
| resources = [] |
| self.resources = resources |
| self.files = files |
| self.builddir = builddir |
| self.platform = platform |
| self.symlink = symlink |
| # misc (derived) attributes |
| self.bundlepath = pathjoin(builddir, self.name + self.bundleextension) |
| self.execdir = pathjoin("Contents", platform) |
| self.resdir = pathjoin("Contents", "Resources") |
| self.verbosity = verbosity |
| |
| 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) |
| os.mkdir(self.bundlepath) |
| self.preProcess() |
| self._copyFiles() |
| self._addMetaFiles() |
| self.postProcess() |
| |
| 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 |
| plist = plistDefaults.copy() |
| plist.CFBundleName = self.name |
| plist.CFBundlePackageType = self.type |
| plist.CFBundleSignature = self.creator |
| plist.update(self.plist) |
| infoplist = pathjoin(contents, "Info.plist") |
| plist.write(infoplist) |
| |
| def _copyFiles(self): |
| files = self.files[:] |
| for path in self.resources: |
| files.append((path, pathjoin("Contents", "Resources", |
| 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" |
| for src, dst in files: |
| 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: |
| sys.stderr.write(msg + "\n") |
| |
| |
| mainWrapperTemplate = """\ |
| #!/usr/bin/env python |
| |
| import os |
| from sys import argv, executable |
| resources = os.path.join(os.path.dirname(os.path.dirname(argv[0])), |
| "Resources") |
| mainprogram = os.path.join(resources, "%(mainprogram)s") |
| assert os.path.exists(mainprogram) |
| argv.insert(1, mainprogram) |
| %(executable)s |
| os.execve(executable, argv, os.environ) |
| """ |
| |
| executableTemplate = "executable = os.path.join(resources, \"%s\")" |
| |
| |
| class AppBuilder(BundleBuilder): |
| |
| """This class extends the BundleBuilder constructor with these |
| arguments: |
| |
| mainprogram: 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.) |
| executable: 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. Else |
| it will simply be used as the main executable. |
| |
| For the other keyword arguments see the BundleBuilder doc string. |
| """ |
| |
| def __init__(self, name=None, mainprogram=None, executable=None, |
| **kwargs): |
| """See the class doc string for a description of the arguments.""" |
| if mainprogram is None and executable is None: |
| raise TypeError, ("must specify either or both of " |
| "'executable' and 'mainprogram'") |
| if name is not None: |
| pass |
| elif mainprogram is not None: |
| name = os.path.splitext(os.path.basename(mainprogram))[0] |
| elif executable is not None: |
| name = os.path.splitext(os.path.basename(executable))[0] |
| if name[-4:] != ".app": |
| name += ".app" |
| |
| self.mainprogram = mainprogram |
| self.executable = executable |
| |
| BundleBuilder.__init__(self, name=name, **kwargs) |
| |
| def preProcess(self): |
| self.plist.CFBundleExecutable = self.name |
| if self.executable is not None: |
| if self.mainprogram is None: |
| execpath = pathjoin(self.execdir, self.name) |
| else: |
| execpath = pathjoin(self.resdir, os.path.basename(self.executable)) |
| self.files.append((self.executable, execpath)) |
| # For execve wrapper |
| executable = executableTemplate % os.path.basename(self.executable) |
| else: |
| executable = "" # XXX for locals() call |
| |
| if self.mainprogram is not None: |
| mainname = os.path.basename(self.mainprogram) |
| self.files.append((self.mainprogram, pathjoin(self.resdir, mainname))) |
| # Create execve wrapper |
| mainprogram = self.mainprogram # XXX for locals() call |
| execdir = pathjoin(self.bundlepath, self.execdir) |
| mainwrapperpath = pathjoin(execdir, self.name) |
| makedirs(execdir) |
| open(mainwrapperpath, "w").write(mainWrapperTemplate % locals()) |
| os.chmod(mainwrapperpath, 0777) |
| |
| |
| class CocoaAppBuilder(AppBuilder): |
| |
| """Tiny specialization of AppBuilder. It has an extra constructor |
| argument called 'nibname' which defaults to 'MainMenu'. It will |
| set the appropriate fields in the plist. |
| """ |
| |
| def __init__(self, nibname="MainMenu", **kwargs): |
| """See the class doc string for a description of the arguments.""" |
| self.nibname = nibname |
| AppBuilder.__init__(self, **kwargs) |
| self.plist.NSMainNibFile = self.nibname |
| if not hasattr(self.plist, "NSPrincipalClass"): |
| self.plist.NSPrincipalClass = "NSApplication" |
| |
| |
| def copy(src, dst, mkdirs=0): |
| """Copy a file or a directory.""" |
| if mkdirs: |
| makedirs(os.path.dirname(dst)) |
| if os.path.isdir(src): |
| shutil.copytree(src, dst) |
| else: |
| shutil.copy2(src, dst) |
| |
| def copytodir(src, dstdir): |
| """Copy a file or a directory to an existing directory.""" |
| dst = pathjoin(dstdir, os.path.basename(src)) |
| copy(src, dst) |
| |
| def makedirs(dir): |
| """Make all directories leading up to 'dir' including the leaf |
| directory. Don't moan if any path element already exists.""" |
| try: |
| os.makedirs(dir) |
| except OSError, why: |
| if why.errno != errno.EEXIST: |
| raise |
| |
| def symlink(src, dst, mkdirs=0): |
| """Copy a file or a directory.""" |
| if mkdirs: |
| makedirs(os.path.dirname(dst)) |
| os.symlink(os.path.abspath(src), dst) |
| |
| def pathjoin(*args): |
| """Safe wrapper for os.path.join: asserts that all but the first |
| argument are relative paths.""" |
| for seg in args[1:]: |
| assert seg[0] != "/" |
| return os.path.join(*args) |
| |
| |
| def buildapp(**kwargs): |
| # XXX cmd line argument parsing |
| builder = AppBuilder(**kwargs) |
| builder.build() |
| |
| |
| def buildcocoaapp(**kwargs): |
| # XXX cmd line argument parsing |
| builder = CocoaAppBuilder(**kwargs) |
| builder.build() |
| |
| |
| if __name__ == "__main__": |
| # XXX This test is meant to be run in the Examples/TableModel/ folder |
| # of the pyobj project... It will go as soon as I've written a proper |
| # main program. |
| buildcocoaapp(mainprogram="TableModel.py", |
| resources=["English.lproj", "nibwrapper.py"], verbosity=4) |