| # -*- coding: ascii -*- |
| # |
| # Copyright 2007, 2008, 2009, 2010, 2011 |
| # Andr\xe9 Malo or his licensors, as applicable |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """ |
| =================== |
| Command extenders |
| =================== |
| |
| Command extenders. |
| """ |
| __author__ = u"Andr\xe9 Malo" |
| __docformat__ = "restructuredtext en" |
| __test__ = False |
| |
| from distutils import fancy_getopt as _fancy_getopt |
| from distutils.command import build as _build |
| from distutils.command import build_ext as _build_ext |
| from distutils.command import install as _install |
| from distutils.command import install_data as _install_data |
| from distutils.command import install_lib as _install_lib |
| import os as _os |
| |
| from _setup.util import log |
| |
| _option_defaults = {} |
| _option_inherits = {} |
| _option_finalizers = {} |
| _command_mapping = { |
| 'install': 'Install', |
| 'install_data': 'InstallData', |
| 'install_lib': 'InstallLib', |
| 'build': 'Build', |
| 'build_ext': 'BuildExt', |
| } |
| |
| |
| def add_option(command, long_name, help_text, short_name=None, default=None, |
| inherit=None): |
| """ Add an option """ |
| try: |
| command_class = globals()[_command_mapping[command]] |
| except KeyError: |
| raise ValueError("Unknown command %r" % (command,)) |
| for opt in command_class.user_options: |
| if opt[0] == long_name: |
| break |
| else: |
| opt = (long_name, short_name, help_text) |
| command_class.user_options.append(opt) |
| if not long_name.endswith('='): |
| command_class.boolean_options.append(long_name) |
| attr_name = _fancy_getopt.translate_longopt(long_name) |
| else: |
| attr_name = _fancy_getopt.translate_longopt(long_name[:-1]) |
| if not _option_defaults.has_key(command): |
| _option_defaults[command] = [] |
| if inherit is not None: |
| if isinstance(inherit, (str, unicode)): |
| inherit = [inherit] |
| for i_inherit in inherit: |
| add_option( |
| i_inherit, long_name, help_text, short_name, default |
| ) |
| default = None |
| if not _option_inherits.has_key(command): |
| _option_inherits[command] = [] |
| for i_inherit in inherit: |
| for i_command, opt_name in _option_inherits[command]: |
| if i_command == i_inherit and opt_name == attr_name: |
| break |
| else: |
| _option_inherits[command].append((i_inherit, attr_name)) |
| _option_defaults[command].append((attr_name, default)) |
| |
| |
| def add_finalizer(command, key, func): |
| """ Add finalizer """ |
| if not _option_finalizers.has_key(command): |
| _option_finalizers[command] = {} |
| if not _option_finalizers[command].has_key(key): |
| _option_finalizers[command][key] = func |
| |
| |
| class Install(_install.install): |
| """ Extended installer to reflect the additional data options """ |
| user_options = _install.install.user_options + [ |
| ('single-version-externally-managed', None, |
| "Compat option. Does not a thing."), |
| ] |
| boolean_options = _install.install.boolean_options + [ |
| 'single-version-externally-managed' |
| ] |
| |
| def initialize_options(self): |
| """ Prepare for new options """ |
| _install.install.initialize_options(self) |
| self.single_version_externally_managed = None |
| if _option_defaults.has_key('install'): |
| for opt_name, default in _option_defaults['install']: |
| setattr(self, opt_name, default) |
| |
| def finalize_options(self): |
| """ Finalize options """ |
| _install.install.finalize_options(self) |
| if _option_inherits.has_key('install'): |
| for parent, opt_name in _option_inherits['install']: |
| self.set_undefined_options(parent, (opt_name, opt_name)) |
| if _option_finalizers.has_key('install'): |
| for func in _option_finalizers['install'].values(): |
| func(self) |
| |
| |
| class InstallData(_install_data.install_data): |
| """ Extended data installer """ |
| user_options = _install_data.install_data.user_options + [] |
| boolean_options = _install_data.install_data.boolean_options + [] |
| |
| def initialize_options(self): |
| """ Prepare for new options """ |
| _install_data.install_data.initialize_options(self) |
| if _option_defaults.has_key('install_data'): |
| for opt_name, default in _option_defaults['install_data']: |
| setattr(self, opt_name, default) |
| |
| def finalize_options(self): |
| """ Finalize options """ |
| _install_data.install_data.finalize_options(self) |
| if _option_inherits.has_key('install_data'): |
| for parent, opt_name in _option_inherits['install_data']: |
| self.set_undefined_options(parent, (opt_name, opt_name)) |
| if _option_finalizers.has_key('install_data'): |
| for func in _option_finalizers['install_data'].values(): |
| func(self) |
| |
| |
| class InstallLib(_install_lib.install_lib): |
| """ Extended lib installer """ |
| user_options = _install_lib.install_lib.user_options + [] |
| boolean_options = _install_lib.install_lib.boolean_options + [] |
| |
| def initialize_options(self): |
| """ Prepare for new options """ |
| _install_lib.install_lib.initialize_options(self) |
| if _option_defaults.has_key('install_lib'): |
| for opt_name, default in _option_defaults['install_lib']: |
| setattr(self, opt_name, default) |
| |
| def finalize_options(self): |
| """ Finalize options """ |
| _install_lib.install_lib.finalize_options(self) |
| if _option_inherits.has_key('install_lib'): |
| for parent, opt_name in _option_inherits['install_lib']: |
| self.set_undefined_options(parent, (opt_name, opt_name)) |
| if _option_finalizers.has_key('install_lib'): |
| for func in _option_finalizers['install_lib'].values(): |
| func(self) |
| |
| |
| class BuildExt(_build_ext.build_ext): |
| """ |
| Extended extension builder class |
| |
| This class allows extensions to provide a ``check_prerequisites`` method |
| which is called before actually building it. The method takes the |
| `BuildExt` instance and returns whether the extension should be skipped or |
| not. |
| """ |
| |
| def initialize_options(self): |
| """ Prepare for new options """ |
| _build_ext.build_ext.initialize_options(self) |
| if _option_defaults.has_key('build_ext'): |
| for opt_name, default in _option_defaults['build_ext']: |
| setattr(self, opt_name, default) |
| |
| def finalize_options(self): |
| """ Finalize options """ |
| _build_ext.build_ext.finalize_options(self) |
| if _option_inherits.has_key('build_ext'): |
| for parent, opt_name in _option_inherits['build_ext']: |
| self.set_undefined_options(parent, (opt_name, opt_name)) |
| if _option_finalizers.has_key('build_ext'): |
| for func in _option_finalizers['build_ext'].values(): |
| func(self) |
| |
| def build_extension(self, ext): |
| """ |
| Build C extension - with extended functionality |
| |
| The following features are added here: |
| |
| - ``ext.check_prerequisites`` is called before the extension is being |
| built. See `Extension` for details. If the method does not exist, |
| simply no check will be run. |
| - The macros ``EXT_PACKAGE`` and ``EXT_MODULE`` will be filled (or |
| unset) depending on the extensions name, but only if they are not |
| already defined. |
| |
| :Parameters: |
| `ext` : `Extension` |
| The extension to build. If it's a pure |
| ``distutils.core.Extension``, simply no prequisites check is |
| applied. |
| |
| :Return: whatever ``distutils.command.build_ext.build_ext`` returns |
| :Rtype: any |
| """ |
| # handle name macros |
| macros = dict(ext.define_macros or ()) |
| tup = ext.name.split('.') |
| if len(tup) == 1: |
| pkg, mod = None, tup[0] |
| else: |
| pkg, mod = '.'.join(tup[:-1]), tup[-1] |
| if pkg is not None and 'EXT_PACKAGE' not in macros: |
| ext.define_macros.append(('EXT_PACKAGE', pkg)) |
| if 'EXT_MODULE' not in macros: |
| ext.define_macros.append(('EXT_MODULE', mod)) |
| if pkg is None: |
| macros = dict(ext.undef_macros or ()) |
| if 'EXT_PACKAGE' not in macros: |
| ext.undef_macros.append('EXT_PACKAGE') |
| |
| # handle prereq checks |
| try: |
| checker = ext.check_prerequisites |
| except AttributeError: |
| pass |
| else: |
| if checker(self): |
| log.info("Skipping %s extension" % ext.name) |
| return |
| |
| return _build_ext.build_ext.build_extension(self, ext) |
| |
| |
| class Build(_build.build): |
| |
| def initialize_options(self): |
| """ Prepare for new options """ |
| _build.build.initialize_options(self) |
| if _option_defaults.has_key('build'): |
| for opt_name, default in _option_defaults['build']: |
| setattr(self, opt_name, default) |
| |
| def finalize_options(self): |
| """ Finalize options """ |
| _build.build.finalize_options(self) |
| if _option_inherits.has_key('build'): |
| for parent, opt_name in _option_inherits['build']: |
| self.set_undefined_options(parent, (opt_name, opt_name)) |
| if _option_finalizers.has_key('build'): |
| for func in _option_finalizers['build'].values(): |
| func(self) |
