|
|
|
|
|
from __future__ import with_statement |
|
|
import logging |
|
|
import os.path |
|
|
from storage import open_storage |
|
|
from storage import resolve_path |
|
|
from storage import makedirs_to_file |
|
|
from storage import put_file |
|
|
from storage import copy_file |
|
|
from storage import iterate_files_recursively |
|
|
from storage._zipfile import ZipFileStorage |
|
|
from storage.fs import FileSystemStorage |
|
|
from manifest import Manifest |
|
|
from description import Description |
|
|
|
|
|
|
|
|
logger = logging.getLogger(__name__) |
|
|
|
|
|
|
|
|
def is_package(folder): |
|
|
if 'META-INF' not in folder: |
|
|
return False |
|
|
if 'manifest.xml' not in folder['META-INF']: |
|
|
return False |
|
|
return True |
|
|
|
|
|
|
|
|
MANIFEST_PATH = os.path.join('META-INF', 'manifest.xml') |
|
|
DESCRIPTION_PATH = 'description.xml' |
|
|
|
|
|
|
|
|
def add_file(stg, manifest, path, full_path, media_type): |
|
|
''' add a file into the storage and manifest. |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
:param path: path to the file on the filesystem. |
|
|
:param full_path: ``manifest:full-path`` value of ``manifest:file-entry`` |
|
|
:param media_type: ``manifest:media-type`` value of ``manifest:file-entry`` |
|
|
''' |
|
|
node = makedirs_to_file(stg, full_path) |
|
|
put_file(node, path) |
|
|
manifest[full_path] = media_type |
|
|
return node |
|
|
|
|
|
|
|
|
def add_component_file(stg, manifest, path, full_path, type, platform=None): |
|
|
''' add a component file. |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
:param path: path to the file on the filesystem. |
|
|
:param full_path: ``manifest:full-path`` value of ``manifest:file-entry`` |
|
|
:param type: ``native``, ``Java``, ``Python`` or None |
|
|
:param platform: supposed platform to run this component. |
|
|
|
|
|
if ``type`` is None, this component is meant to be registered with |
|
|
`Passive Component Registration |
|
|
<http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/Passive_Component_Registration>`_ |
|
|
and the file specified with ``path`` should be an XML file, which is |
|
|
defined in the document above. |
|
|
|
|
|
For more informations, see `File Format |
|
|
<http://wiki.openoffice.org/wiki/Documentation/DevGuide/Extensions/File_Format>`_. |
|
|
''' |
|
|
mimetype = 'application/vnd.sun.star.uno-component' |
|
|
if type: |
|
|
mimetype += '; ' + type |
|
|
if platform: |
|
|
mimetype += '; ' + platform |
|
|
return add_file(stg, manifest, path, full_path, mimetype=mimetype) |
|
|
|
|
|
|
|
|
def add_type_library(stg, manifest, path, full_path, type): |
|
|
''' add a UNO type library. |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
:param type: ``RDB`` or ``Java`` |
|
|
''' |
|
|
|
|
|
typelib_extensions = dict(RDB='.rdb', Java='.jar') |
|
|
|
|
|
if type not in typelib_extensions.keys(): |
|
|
raise ValueError('type: unsupported value of %r' % type) |
|
|
|
|
|
if not full_path.lower().endswith(typelib_extensions[type]): |
|
|
msg = 'adding %r type library %r with name %r: really intended?' |
|
|
logger.warning(msg, type, path, full_path) |
|
|
|
|
|
mimetype = 'application/vnd.sun.star.uno-typelibrary' |
|
|
mimetype += '; type=' + type |
|
|
return add_file(stg, manifest, path, full_path, mimetype) |
|
|
|
|
|
|
|
|
def add_basic_library(stg, manifest, path, full_path): |
|
|
''' add a basic library |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
''' |
|
|
mimetype = 'application/vnd.sun.star.basic-library' |
|
|
return add_file(stg, manifest, path, full_path, mimetype=mimetype) |
|
|
|
|
|
|
|
|
def add_dialog_library(stg, manifest, path, full_path): |
|
|
''' add a dialog library |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
''' |
|
|
mimetype = 'application/vnd.sun.star.dialog-library' |
|
|
return add_file(stg, manifest, path, full_path, mimetype=mimetype) |
|
|
|
|
|
|
|
|
def add_configuration_data_file(stg, manifest, path, full_path): |
|
|
''' add a configuration data file. |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
''' |
|
|
mimetype = 'application/vnd.sun.star.configuration-data' |
|
|
return add_file(stg, manifest, path, full_path, mimetype=mimetype) |
|
|
|
|
|
|
|
|
def add_configuration_schema_file(stg, manifest, path, full_path): |
|
|
''' add a configuration schema file. |
|
|
|
|
|
:param stg: a storage |
|
|
:param manifest: an instance of Manifest |
|
|
''' |
|
|
mimetype = 'application/vnd.sun.star.configuration-schema' |
|
|
return add_file(stg, manifest, path, full_path, mimetype=mimetype) |
|
|
|
|
|
|
|
|
def build(package_path, manifest, description, files=dict(), |
|
|
storage_factory=ZipFileStorage): |
|
|
''' Build a OXT Package. |
|
|
|
|
|
:param package_path: path to an .oxt package to be built |
|
|
:param manifest: an instance of Manifest |
|
|
:param description: an instance of Description |
|
|
:param files: package files, in a form of (path, node) dict |
|
|
:param storage_factory: storage factory for the package. |
|
|
Default to ZipFileStorage |
|
|
''' |
|
|
|
|
|
assert not any(node is None for node in files.values()) |
|
|
assert all(path in files for path in manifest) |
|
|
assert all(path in files for path in description.required_files()) |
|
|
|
|
|
logger.info('creating %s', package_path) |
|
|
with storage_factory(package_path, 'w') as stg: |
|
|
logger.info('writing %s', MANIFEST_PATH) |
|
|
manifest_node = makedirs_to_file(stg, MANIFEST_PATH) |
|
|
with manifest_node.open('w') as f: |
|
|
manifest.dump(f) |
|
|
|
|
|
logger.info('writing %s', DESCRIPTION_PATH) |
|
|
desc_node = makedirs_to_file(stg, DESCRIPTION_PATH) |
|
|
with desc_node.open('w') as f: |
|
|
description.write(f) |
|
|
|
|
|
for path in sorted(files): |
|
|
node = files[path] |
|
|
logger.info('writing %s', path) |
|
|
dest = makedirs_to_file(stg, path) |
|
|
copy_file(node, dest) |
|
|
|
|
|
|
|
|
def build_from(package_path, |
|
|
src_folder, |
|
|
manifest_path=None, |
|
|
description_path=None, |
|
|
files=[], |
|
|
excludes=[], |
|
|
storage_factory=ZipFileStorage): |
|
|
|
|
|
if manifest_path: |
|
|
with file(manifest_path) as f: |
|
|
manifest = Manifest() |
|
|
manifest.load(f) |
|
|
else: |
|
|
node = resolve_path(src_folder, MANIFEST_PATH) |
|
|
if node: |
|
|
with node.open() as f: |
|
|
manifest = Manifest() |
|
|
manifest.load(f) |
|
|
else: |
|
|
logger.error('%s: not found' % MANIFEST_PATH) |
|
|
raise IOError('%s: not found' % MANIFEST_PATH) |
|
|
|
|
|
if description_path: |
|
|
with file(description_path) as f: |
|
|
description = Description.parse(f) |
|
|
else: |
|
|
node = resolve_path(src_folder, DESCRIPTION_PATH) |
|
|
if node: |
|
|
with node.open() as f: |
|
|
description = Description.parse(f) |
|
|
else: |
|
|
raise IOError('%s: not found' % DESCRIPTION_PATH) |
|
|
|
|
|
package_path = make_output_path(package_path, description) |
|
|
package_files = dict() |
|
|
|
|
|
from itertools import chain |
|
|
required_files = chain(manifest, description.required_files()) |
|
|
for path in required_files: |
|
|
node = resolve_path(src_folder, path) |
|
|
if node is None: |
|
|
raise IOError('%s: not found' % path) |
|
|
package_files[path] = node |
|
|
|
|
|
files = ((path, resolve_path(src_folder, path)) for path in files) |
|
|
files = expand_folders(files) |
|
|
files = exclude_files(excludes, files) |
|
|
package_files.update(files) |
|
|
|
|
|
return build(package_path, manifest, description, package_files, |
|
|
storage_factory=storage_factory) |
|
|
|
|
|
|
|
|
def make_output_path(path, desc=None): |
|
|
if os.path.isdir(path): |
|
|
dirname = path |
|
|
name = '' |
|
|
else: |
|
|
dirname, name = os.path.split(path) |
|
|
|
|
|
|
|
|
if name == '': |
|
|
if desc is None: |
|
|
raise ValueError('%s: invalid path' % path) |
|
|
name = package_name_from_desc(desc) |
|
|
|
|
|
return os.path.join(dirname, name) |
|
|
|
|
|
|
|
|
def package_name_from_desc(desc): |
|
|
id = desc.identifier |
|
|
version = desc.version |
|
|
if version: |
|
|
return '-'.join([id, version]) + '.oxt' |
|
|
else: |
|
|
return id + '.oxt' |
|
|
|
|
|
|
|
|
def expand_folders(resolved_nodes): |
|
|
for path, node in resolved_nodes: |
|
|
if hasattr(node, '__iter__'): |
|
|
for path, node in iterate_files_recursively(node, path): |
|
|
yield path, node |
|
|
else: |
|
|
yield path, node |
|
|
|
|
|
|
|
|
def exclude_files(patterns, resolved_nodes): |
|
|
from fnmatch import fnmatch |
|
|
for path, node in resolved_nodes: |
|
|
excluded = False |
|
|
for pat in patterns: |
|
|
if fnmatch(path, pat): |
|
|
logger.info('exclude %s (by %s)', path, pat) |
|
|
excluded = True |
|
|
if not excluded: |
|
|
yield path, node |
|
|
|
|
|
|
|
|
def init_main(): |
|
|
doc = '''Usage: oxt-pkg-init [options] <package-path> |
|
|
|
|
|
--help Print this screen. |
|
|
''' |
|
|
|
|
|
from docopt import docopt |
|
|
args = docopt(doc) |
|
|
logging.basicConfig(level=logging.INFO) |
|
|
|
|
|
package_path = args['<package-path>'] |
|
|
|
|
|
manifest = Manifest() |
|
|
description = Description() |
|
|
|
|
|
with open_storage(package_path, 'w') as stg: |
|
|
with makedirs_to_file(stg, MANIFEST_PATH).open('w') as f: |
|
|
manifest.dump(f) |
|
|
with makedirs_to_file(stg, DESCRIPTION_PATH).open('w') as f: |
|
|
description.write(f) |
|
|
|
|
|
|
|
|
def show_main(): |
|
|
doc = '''Usage: oxt-pkg-show [options] <package-path> |
|
|
|
|
|
--help Print this screen. |
|
|
''' |
|
|
|
|
|
from docopt import docopt |
|
|
args = docopt(doc) |
|
|
logging.basicConfig(level=logging.INFO) |
|
|
|
|
|
package_path = args['<package-path>'] |
|
|
with open_storage(package_path) as pkg: |
|
|
with resolve_path(pkg, MANIFEST_PATH).open() as f: |
|
|
manifest = Manifest() |
|
|
manifest.load(f) |
|
|
|
|
|
with resolve_path(pkg, DESCRIPTION_PATH).open() as f: |
|
|
description = Description.parse(f) |
|
|
|
|
|
from description import print_human_readable |
|
|
print_human_readable(description, pkg) |
|
|
|
|
|
for path in manifest: |
|
|
item = manifest[path] |
|
|
print path, item['media-type'], |
|
|
node = resolve_path(pkg, path) |
|
|
if node: |
|
|
print '-- OK' |
|
|
else: |
|
|
print '-- MISSING' |
|
|
|
|
|
|
|
|
def build_main(): |
|
|
doc = '''Usage: oxt-pkg-build [options] <src-folder> <add-files>... |
|
|
|
|
|
-o OUTPUT-PATH Output path |
|
|
-m MANIFEST META-INF/manifest.xml |
|
|
-d DESCRIPT description.xml |
|
|
-E EXCLUDE, --exclude=EXCLUDE exclude patterns; separated by %r. |
|
|
--help Print this screen. |
|
|
|
|
|
<src-folder> root folder containing package files |
|
|
<add-files> additional files (relative to <src-folder>) |
|
|
''' % os.pathsep |
|
|
|
|
|
from docopt import docopt |
|
|
args = docopt(doc) |
|
|
logging.basicConfig(level=logging.INFO) |
|
|
|
|
|
src_folder_path = args['<src-folder>'] |
|
|
add_files = args['<add-files>'] |
|
|
output_path = args['-o'] or '.' |
|
|
manifest_path = args['-m'] |
|
|
description_path = args['-d'] |
|
|
excludes = args['--exclude'] or '' |
|
|
excludes = excludes.strip().split(os.pathsep) |
|
|
|
|
|
with FileSystemStorage(src_folder_path) as src_folder: |
|
|
build_from(output_path, |
|
|
src_folder, |
|
|
manifest_path=manifest_path, |
|
|
description_path=description_path, |
|
|
files=add_files, |
|
|
excludes=excludes) |
|
|
|
|
|
|
|
|
def check_main(): |
|
|
doc = '''Usage: oxt-pkg-show [options] <package-path> |
|
|
|
|
|
--help Print this screen. |
|
|
''' |
|
|
|
|
|
from docopt import docopt |
|
|
args = docopt(doc) |
|
|
logging.basicConfig(level=logging.INFO) |
|
|
|
|
|
package_path = args['<package-path>'] |
|
|
with open_storage(package_path) as pkg: |
|
|
with resolve_path(pkg, MANIFEST_PATH).open() as f: |
|
|
manifest = Manifest() |
|
|
manifest.load(f) |
|
|
|
|
|
with resolve_path(pkg, DESCRIPTION_PATH).open() as f: |
|
|
description = Description.parse(f) |
|
|
|
|
|
missing = dict() |
|
|
|
|
|
for path in manifest: |
|
|
node = resolve_path(pkg, path) |
|
|
if node is None: |
|
|
missing[path] = MANIFEST_PATH |
|
|
|
|
|
for path in description.required_files(): |
|
|
node = resolve_path(pkg, path) |
|
|
if node is None: |
|
|
missing[path] = DESCRIPTION_PATH |
|
|
|
|
|
if missing: |
|
|
for path in sorted(missing): |
|
|
referer = missing[path] |
|
|
logger.error('%s: MISSING (refered in %s)', |
|
|
path, referer) |
|
|
raise SystemExit(1) |
|
|
else: |
|
|
logger.info('%s: OK, identifier=%s, version=%s', package_path, |
|
|
description.identifier, description.version) |
|
|
|
