Support PYTHON_BDEPEND. Disallow PYTHON_USE_WITH, PYTHON_USE_WITH_OR and PYTHON_USE_WITH_OPT in EAPI >=4. (Patch by Arfrever. Backported from Progress Overlay.) --- python.eclass +++ python.eclass @@ -112,19 +112,19 @@ # minimal_version: # maximal_version: -_python_parse_PYTHON_DEPEND() { - local major_version maximal_version minimal_version python_all="0" python_maximal_version python_minimal_version python_versions=() python2="0" python2_maximal_version python2_minimal_version python3="0" python3_maximal_version python3_minimal_version USE_flag= version_components_group version_components_group_regex version_components_groups +_python_parse_versions_range() { + local input_value input_variable major_version maximal_version minimal_version output_variable python_atoms=() python_all="0" python_maximal_version python_minimal_version python_versions=() python2="0" python2_maximal_version python2_minimal_version python3="0" python3_maximal_version python3_minimal_version version_components_group version_components_groups + + input_value="$1" + input_variable="$2" + output_variable="$3" version_components_group_regex="(2|3|\*)(:([[:digit:]]+\.[[:digit:]]+)?(:([[:digit:]]+\.[[:digit:]]+)?)?)?" - version_components_groups="${PYTHON_DEPEND}" + version_components_groups="${input_value}" - if [[ "${version_components_groups}" =~ ^((\!)?[[:alnum:]_-]+\?\ )?${version_components_group_regex}(\ ${version_components_group_regex})?$ ]]; then - if [[ "${version_components_groups}" =~ ^(\!)?[[:alnum:]_-]+\? ]]; then - USE_flag="${version_components_groups%\? *}" - version_components_groups="${version_components_groups#* }" - fi + if [[ "${version_components_groups}" =~ ^${version_components_group_regex}(\ ${version_components_group_regex})?$ ]]; then if [[ "${version_components_groups}" =~ ("*".*" "|" *"|^2.*\ (2|\*)|^3.*\ (3|\*)) ]]; then - die "Invalid syntax of PYTHON_DEPEND: Incorrectly specified groups of versions" + die "Invalid syntax of ${input_variable}: Incorrectly specified groups of versions" fi version_components_groups="${version_components_groups// /$'\n'}" @@ -136,10 +136,10 @@ if [[ "${major_version}" =~ ^(2|3)$ ]]; then if [[ -n "${minimal_version}" && "${major_version}" != "${minimal_version:0:1}" ]]; then - die "Invalid syntax of PYTHON_DEPEND: Minimal version '${minimal_version}' not in specified group of versions" + die "Invalid syntax of ${input_variable}: Minimal version '${minimal_version}' not in specified group of versions" fi if [[ -n "${maximal_version}" && "${major_version}" != "${maximal_version:0:1}" ]]; then - die "Invalid syntax of PYTHON_DEPEND: Maximal version '${maximal_version}' not in specified group of versions" + die "Invalid syntax of ${input_variable}: Maximal version '${maximal_version}' not in specified group of versions" fi fi @@ -161,19 +161,17 @@ fi if [[ -n "${minimal_version}" ]] && ! has "${minimal_version}" "${python_versions[@]}"; then - die "Invalid syntax of PYTHON_DEPEND: Unrecognized minimal version '${minimal_version}'" + die "Invalid syntax of ${input_variable}: Unrecognized minimal version '${minimal_version}'" fi if [[ -n "${maximal_version}" ]] && ! has "${maximal_version}" "${python_versions[@]}"; then - die "Invalid syntax of PYTHON_DEPEND: Unrecognized maximal version '${maximal_version}'" + die "Invalid syntax of ${input_variable}: Unrecognized maximal version '${maximal_version}'" fi if [[ -n "${minimal_version}" && -n "${maximal_version}" && "${minimal_version}" > "${maximal_version}" ]]; then - die "Invalid syntax of PYTHON_DEPEND: Minimal version '${minimal_version}' greater than maximal version '${maximal_version}'" + die "Invalid syntax of ${input_variable}: Minimal version '${minimal_version}' greater than maximal version '${maximal_version}'" fi done <<< "${version_components_groups}" - _PYTHON_ATOMS=() - _append_accepted_versions_range() { local accepted_version="0" i for ((i = "${#python_versions[@]}"; i >= 0; i--)); do @@ -181,7 +179,7 @@ accepted_version="1" fi if [[ "${accepted_version}" == "1" ]]; then - _PYTHON_ATOMS+=("=dev-lang/python-${python_versions[${i}]}*") + python_atoms+=("=dev-lang/python-${python_versions[${i}]}*") fi if [[ "${python_versions[${i}]}" == "${python_minimal_version}" ]]; then accepted_version="0" @@ -191,7 +189,7 @@ if [[ "${python_all}" == "1" ]]; then if [[ -z "${python_minimal_version}" && -z "${python_maximal_version}" ]]; then - _PYTHON_ATOMS+=("dev-lang/python") + python_atoms+=("dev-lang/python") else python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}") python_minimal_version="${python_minimal_version:-${python_versions[0]}}" @@ -201,7 +199,7 @@ else if [[ "${python3}" == "1" ]]; then if [[ -z "${python3_minimal_version}" && -z "${python3_maximal_version}" ]]; then - _PYTHON_ATOMS+=("=dev-lang/python-3*") + python_atoms+=("=dev-lang/python-3*") else python_versions=("${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}") python_minimal_version="${python3_minimal_version:-${python_versions[0]}}" @@ -211,7 +209,7 @@ fi if [[ "${python2}" == "1" ]]; then if [[ -z "${python2_minimal_version}" && -z "${python2_maximal_version}" ]]; then - _PYTHON_ATOMS+=("=dev-lang/python-2*") + python_atoms+=("=dev-lang/python-2*") else python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}") python_minimal_version="${python2_minimal_version:-${python_versions[0]}}" @@ -223,74 +221,150 @@ unset -f _append_accepted_versions_range + eval "${output_variable}=(\"\${python_atoms[@]}\")" + else + die "Invalid syntax of ${input_variable}" + fi +} + +_python_parse_dependencies_in_old_EAPIs() { + local USE_flag variable variables version_components_group_regex version_components_groups + + version_components_group_regex="(2|3|\*)(:([[:digit:]]+\.[[:digit:]]+)?(:([[:digit:]]+\.[[:digit:]]+)?)?)?" + version_components_groups="${!1}" + variables="$2" + + if [[ "${version_components_groups}" =~ ^((\!)?[[:alnum:]_-]+\?\ )?${version_components_group_regex}(\ ${version_components_group_regex})?$ ]]; then + if [[ "${version_components_groups}" =~ ^(\!)?[[:alnum:]_-]+\? ]]; then + USE_flag="${version_components_groups%\? *}" + version_components_groups="${version_components_groups#* }" + fi + + _python_parse_versions_range "${version_components_groups}" "$1" _PYTHON_ATOMS + if [[ "${#_PYTHON_ATOMS[@]}" -gt 1 ]]; then - DEPEND+="${DEPEND:+ }${USE_flag}${USE_flag:+? ( }|| ( ${_PYTHON_ATOMS[@]} )${USE_flag:+ )}" - RDEPEND+="${RDEPEND:+ }${USE_flag}${USE_flag:+? ( }|| ( ${_PYTHON_ATOMS[@]} )${USE_flag:+ )}" + for variable in ${variables}; do + eval "${variable}+=\"\${!variable:+ }\${USE_flag}\${USE_flag:+? ( }|| ( \${_PYTHON_ATOMS[@]} )\${USE_flag:+ )}\"" + done else - DEPEND+="${DEPEND:+ }${USE_flag}${USE_flag:+? ( }${_PYTHON_ATOMS[@]}${USE_flag:+ )}" - RDEPEND+="${RDEPEND:+ }${USE_flag}${USE_flag:+? ( }${_PYTHON_ATOMS[@]}${USE_flag:+ )}" + for variable in ${variables}; do + eval "${variable}+=\"\${!variable:+ }\${USE_flag}\${USE_flag:+? ( }\${_PYTHON_ATOMS[@]}\${USE_flag:+ )}\"" + done fi else - die "Invalid syntax of PYTHON_DEPEND" + die "Invalid syntax of $1" fi } +_python_parse_dependencies_in_new_EAPIs() { + : +} + DEPEND=">=app-admin/eselect-python-20091230" RDEPEND="${DEPEND}" -if [[ -n "${PYTHON_DEPEND}" ]]; then - _python_parse_PYTHON_DEPEND +if has "${EAPI:-0}" 0 1 2 3; then + _PYTHON_ATOMS_FROM_PYTHON_DEPEND=() + _PYTHON_ATOMS_FROM_PYTHON_BDEPEND=() + if [[ -z "${PYTHON_DEPEND}" && -z "${PYTHON_BDEPEND}" ]]; then + _PYTHON_ATOMS_FROM_PYTHON_DEPEND=("dev-lang/python") + fi + if [[ -n "${PYTHON_DEPEND}" ]]; then + _python_parse_dependencies_in_old_EAPIs PYTHON_DEPEND "DEPEND RDEPEND" + _PYTHON_ATOMS_FROM_PYTHON_DEPEND=("${_PYTHON_ATOMS[@]}") + fi + if [[ -n "${PYTHON_BDEPEND}" ]]; then + _python_parse_dependencies_in_old_EAPIs PYTHON_BDEPEND "DEPEND" + _PYTHON_ATOMS_FROM_PYTHON_BDEPEND=("${_PYTHON_ATOMS[@]}") + fi + unset _PYTHON_ATOMS else - _PYTHON_ATOMS=("dev-lang/python") -fi -unset -f _python_parse_PYTHON_DEPEND - -if [[ -n "${NEED_PYTHON}" ]]; then - eerror "Use PYTHON_DEPEND variable instead of NEED_PYTHON variable." - die "NEED_PYTHON variable is banned" + _python_parse_dependencies_in_new_EAPIs fi +unset -f _python_parse_versions_range _python_parse_dependencies_in_old_EAPIs _python_parse_dependencies_in_new_EAPIs # @ECLASS-VARIABLE: PYTHON_USE_WITH # @DESCRIPTION: # Set this to a space separated list of USE flags the Python slot in use must be built with. +# This variable can be used only in EAPI 2 and 3. # @ECLASS-VARIABLE: PYTHON_USE_WITH_OR # @DESCRIPTION: # Set this to a space separated list of USE flags of which one must be turned on for the slot in use. +# This variable is ignored when PYTHON_USE_WITH is set. +# This variable can be used only in EAPI 2 and 3. # @ECLASS-VARIABLE: PYTHON_USE_WITH_OPT # @DESCRIPTION: # Set this to a name of a USE flag if you need to make either PYTHON_USE_WITH or # PYTHON_USE_WITH_OR atoms conditional under a USE flag. +# This variable can be used only in EAPI 2 and 3. -if ! has "${EAPI:-0}" 0 1 && [[ -n ${PYTHON_USE_WITH} || -n ${PYTHON_USE_WITH_OR} ]]; then - _PYTHON_USE_WITH_ATOMS_ARRAY=() - if [[ -n "${PYTHON_USE_WITH}" ]]; then - for _PYTHON_ATOM in "${_PYTHON_ATOMS[@]}"; do - _PYTHON_USE_WITH_ATOMS_ARRAY+=("${_PYTHON_ATOM}[${PYTHON_USE_WITH// /,}]") - done - elif [[ -n "${PYTHON_USE_WITH_OR}" ]]; then - for _USE_flag in ${PYTHON_USE_WITH_OR}; do - for _PYTHON_ATOM in "${_PYTHON_ATOMS[@]}"; do - _PYTHON_USE_WITH_ATOMS_ARRAY+=("${_PYTHON_ATOM}[${_USE_flag}]") +if has "${EAPI:-0}" 2 3; then + if [[ -n "${PYTHON_USE_WITH}" || -n "${PYTHON_USE_WITH_OR}" ]]; then + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND=() + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND=() + if [[ -n "${PYTHON_USE_WITH}" ]]; then + for _PYTHON_ATOM in "${_PYTHON_ATOMS_FROM_PYTHON_DEPEND[@]}"; do + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND+=("${_PYTHON_ATOM}[${PYTHON_USE_WITH// /,}]") + done + for _PYTHON_ATOM in "${_PYTHON_ATOMS_FROM_PYTHON_BDEPEND[@]}"; do + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND+=("${_PYTHON_ATOM}[${PYTHON_USE_WITH// /,}]") + done + elif [[ -n "${PYTHON_USE_WITH_OR}" ]]; then + for _USE_flag in ${PYTHON_USE_WITH_OR}; do + for _PYTHON_ATOM in "${_PYTHON_ATOMS_FROM_PYTHON_DEPEND[@]}"; do + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND+=("${_PYTHON_ATOM}[${_USE_flag}]") + done + for _PYTHON_ATOM in "${_PYTHON_ATOMS_FROM_PYTHON_BDEPEND[@]}"; do + _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND+=("${_PYTHON_ATOM}[${_USE_flag}]") + done done - done - unset _USE_flag + unset _USE_flag + fi + if [[ "${#_PYTHON_ATOMS_FROM_PYTHON_DEPEND[@]}" -gt 0 ]]; then + if [[ "${#_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND[@]}" -gt 1 ]]; then + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND="|| ( ${_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND[@]} )" + else + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND="${_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND[@]}" + fi + if [[ -n "${PYTHON_USE_WITH_OPT}" ]]; then + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND="${PYTHON_USE_WITH_OPT}? ( ${_PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND} )" + fi + DEPEND+=" ${_PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND}" + RDEPEND+=" ${_PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND}" + fi + if [[ "${#_PYTHON_ATOMS_FROM_PYTHON_BDEPEND[@]}" -gt 0 ]]; then + if [[ "${#_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND[@]}" -gt 1 ]]; then + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND="|| ( ${_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND[@]} )" + else + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND="${_PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND[@]}" + fi + if [[ -n "${PYTHON_USE_WITH_OPT}" ]]; then + _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND="${PYTHON_USE_WITH_OPT}? ( ${_PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND} )" + fi + DEPEND+=" ${_PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND}" + fi + unset _PYTHON_ATOM _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_DEPEND _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_DEPEND _PYTHON_USE_WITH_ATOMS_FROM_PYTHON_BDEPEND _PYTHON_USE_WITH_ATOMS_ARRAY_FROM_PYTHON_BDEPEND fi - if [[ "${#_PYTHON_USE_WITH_ATOMS_ARRAY[@]}" -gt 1 ]]; then - _PYTHON_USE_WITH_ATOMS="|| ( ${_PYTHON_USE_WITH_ATOMS_ARRAY[@]} )" - else - _PYTHON_USE_WITH_ATOMS="${_PYTHON_USE_WITH_ATOMS_ARRAY[@]}" +else + if [[ -n "${PYTHON_USE_WITH}" ]]; then + eerror "Use PYTHON_DEPEND variable instead of PYTHON_USE_WITH variable." + die "PYTHON_USE_WITH variable is banned" + fi + if [[ -n "${PYTHON_USE_WITH_OR}" ]]; then + eerror "Use PYTHON_DEPEND variable instead of PYTHON_USE_WITH_OR variable." + die "PYTHON_USE_WITH_OR variable is banned" fi if [[ -n "${PYTHON_USE_WITH_OPT}" ]]; then - _PYTHON_USE_WITH_ATOMS="${PYTHON_USE_WITH_OPT}? ( ${_PYTHON_USE_WITH_ATOMS} )" + eerror "Use PYTHON_DEPEND variable instead of PYTHON_USE_WITH_OPT variable." + die "PYTHON_USE_WITH_OPT variable is banned" fi - DEPEND+=" ${_PYTHON_USE_WITH_ATOMS}" - RDEPEND+=" ${_PYTHON_USE_WITH_ATOMS}" - unset _PYTHON_ATOM _PYTHON_USE_WITH_ATOMS _PYTHON_USE_WITH_ATOMS_ARRAY fi -unset _PYTHON_ATOMS +if has "${EAPI:-0}" 0 1 2 3; then + unset _PYTHON_ATOMS_FROM_PYTHON_DEPEND _PYTHON_ATOMS_FROM_PYTHON_BDEPEND +fi # ================================================================================================ # =================================== MISCELLANEOUS FUNCTIONS ====================================