diff options
Diffstat (limited to 'catapult/common/py_vulcanize/third_party/rcssmin/_setup/py3/commands.py')
| -rw-r--r-- | catapult/common/py_vulcanize/third_party/rcssmin/_setup/py3/commands.py | 266 |
1 files changed, 266 insertions, 0 deletions
diff --git a/catapult/common/py_vulcanize/third_party/rcssmin/_setup/py3/commands.py b/catapult/common/py_vulcanize/third_party/rcssmin/_setup/py3/commands.py new file mode 100644 index 00000000..7bfacbc8 --- /dev/null +++ b/catapult/common/py_vulcanize/third_party/rcssmin/_setup/py3/commands.py @@ -0,0 +1,266 @@ +# -*- 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__ = "Andr\xe9 Malo" +__docformat__ = "restructuredtext en" +__test__ = False + +from distutils import fancy_getopt as _fancy_getopt +from distutils import log +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 + +_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 command not in _option_defaults: + _option_defaults[command] = [] + if inherit is not None: + if isinstance(inherit, str): + inherit = [inherit] + for i_inherit in inherit: + add_option( + i_inherit, long_name, help_text, short_name, default + ) + default = None + if command not in _option_inherits: + _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 command not in _option_finalizers: + _option_finalizers[command] = {} + if key not in _option_finalizers[command]: + _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 'install' in _option_defaults: + 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 'install' in _option_inherits: + for parent, opt_name in _option_inherits['install']: + self.set_undefined_options(parent, (opt_name, opt_name)) + if 'install' in _option_finalizers: + for func in list(_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 'install_data' in _option_defaults: + 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 'install_data' in _option_inherits: + for parent, opt_name in _option_inherits['install_data']: + self.set_undefined_options(parent, (opt_name, opt_name)) + if 'install_data' in _option_finalizers: + for func in list(_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 'install_lib' in _option_defaults: + 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 'install_lib' in _option_inherits: + for parent, opt_name in _option_inherits['install_lib']: + self.set_undefined_options(parent, (opt_name, opt_name)) + if 'install_lib' in _option_finalizers: + for func in list(_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 'build_ext' in _option_defaults: + 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 'build_ext' in _option_inherits: + for parent, opt_name in _option_inherits['build_ext']: + self.set_undefined_options(parent, (opt_name, opt_name)) + if 'build_ext' in _option_finalizers: + for func in list(_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 'build' in _option_defaults: + 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 'build' in _option_inherits: + for parent, opt_name in _option_inherits['build']: + self.set_undefined_options(parent, (opt_name, opt_name)) + if 'build' in _option_finalizers: + for func in list(_option_finalizers['build'].values()): + func(self) |