Tools to create MacOS X (application) bundles.
Todo: - command line parsing - main program - modulefinder(-like ;-) support to build standalone apps.
This commit is contained in:
Just van Rossum
parent
4fc904708b
commit
ad33d72361
|
|
@ -0,0 +1,307 @@
|
|||
#! /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)
|
||||
Loading…
Reference in New Issue