/[gentoo-x86]/eclass/java-utils-2.eclass
Gentoo

Diff of /eclass/java-utils-2.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.70 Revision 1.101
4# Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org> 4# Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org>
5# Copyright (c) 2004-2005, Gentoo Foundation 5# Copyright (c) 2004-2005, Gentoo Foundation
6# 6#
7# Licensed under the GNU General Public License, v2 7# Licensed under the GNU General Public License, v2
8# 8#
9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.70 2007/04/17 09:16:22 ali_bush Exp $ 9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.101 2008/01/12 15:03:13 caster Exp $
10
11 10
12# ----------------------------------------------------------------------------- 11# -----------------------------------------------------------------------------
13# @eclass-begin 12# @eclass-begin
14# @eclass-shortdesc Java Utility eclass 13# @eclass-shortdesc Java Utility eclass
15# @eclass-maintainer java@gentoo.org 14# @eclass-maintainer java@gentoo.org
58#WANT_ANT_TASKS 57#WANT_ANT_TASKS
59 58
60# ----------------------------------------------------------------------------- 59# -----------------------------------------------------------------------------
61# @variable-internal JAVA_PKG_PORTAGE_DEP 60# @variable-internal JAVA_PKG_PORTAGE_DEP
62# 61#
63# The version of portage we need to function properly. At this moment it's 62# The version of portage we need to function properly. Previously it was
64# portage with phase hooks support. 63# portage with phase hooks support but now we use a version with proper env
64# saving.
65# ----------------------------------------------------------------------------- 65# -----------------------------------------------------------------------------
66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1" 66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
67 67
68# ----------------------------------------------------------------------------- 68# -----------------------------------------------------------------------------
69# @variable-internal JAVA_PKG_E_DEPEND 69# @variable-internal JAVA_PKG_E_DEPEND
70# 70#
71# This is a convience variable to be used from the other java eclasses. This is 71# This is a convience variable to be used from the other java eclasses. This is
72# the version of java-config we want to use. We also need a recent version 72# the version of java-config we want to use. Usually the latest stable version
73# portage, that includes phase hooks. 73# so that ebuilds can use new features without depending on specific versions.
74# ----------------------------------------------------------------------------- 74# -----------------------------------------------------------------------------
75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.31 ${JAVA_PKG_PORTAGE_DEP}" 75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.33-r1 ${JAVA_PKG_PORTAGE_DEP}"
76hasq source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
76 77
77# ----------------------------------------------------------------------------- 78# -----------------------------------------------------------------------------
78# @variable-external JAVA_PKG_ALLOW_VM_CHANGE 79# @variable-external JAVA_PKG_ALLOW_VM_CHANGE
79# @variable-default yes 80# @variable-default yes
80# 81#
195# 196#
196# @example 197# @example
197# java-pkg_doexamples demo 198# java-pkg_doexamples demo
198# java-pkg_doexamples demo/* examples/* 199# java-pkg_doexamples demo/* examples/*
199# 200#
201# @param --subdir - If the examples need a certain directory structure
200# @param $* - list of files to install 202# @param $* - list of files to install
201# ------------------------------------------------------------------------------ 203# ------------------------------------------------------------------------------
202java-pkg_doexamples() { 204java-pkg_doexamples() {
203 debug-print-function ${FUNCNAME} $* 205 debug-print-function ${FUNCNAME} $*
204 206
205 [[ ${#} -lt 1 ]] && die "At least one argument needed" 207 [[ ${#} -lt 1 ]] && die "At least one argument needed"
206 208
207 java-pkg_check-phase install 209 java-pkg_check-phase install
208 210
209 local dest=/usr/share/doc/${PF}/examples 211 local dest=/usr/share/doc/${PF}/examples
212 if [[ ${1} == --subdir ]]; then
213 local dest=${dest}/${2}
214 dodir ${dest}
215 shift 2
216 fi
217
210 if [[ ${#} = 1 && -d ${1} ]]; then 218 if [[ ${#} = 1 && -d ${1} ]]; then
211 ( # dont want to pollute calling env 219 ( # dont want to pollute calling env
212 insinto "${dest}" 220 insinto "${dest}"
213 doins -r ${1}/* 221 doins -r ${1}/*
214 ) || die "Installing examples failed" 222 ) || die "Installing examples failed"
549# ------------------------------------------------------------------------------ 557# ------------------------------------------------------------------------------
550# @ebuild-function java-pkg_dojavadoc 558# @ebuild-function java-pkg_dojavadoc
551# 559#
552# Installs javadoc documentation. This should be controlled by the doc use flag. 560# Installs javadoc documentation. This should be controlled by the doc use flag.
553# 561#
562# @param $1: optional --symlink creates to symlink like this for html
563# documentation bundles.
554# @param $1: - The javadoc root directory. 564# @param $2: - The javadoc root directory.
555# 565#
556# @example: 566# @example:
557# java-pkg_dojavadoc docs/api 567# java-pkg_dojavadoc docs/api
568# java-pkg_dojavadoc --symlink apidocs docs/api
558# 569#
559# ------------------------------------------------------------------------------ 570# ------------------------------------------------------------------------------
560java-pkg_dojavadoc() { 571java-pkg_dojavadoc() {
572 debug-print-function ${FUNCNAME} $*
573
574 # For html documentation bundles that link to Javadoc
575 local symlink
576 if [[ ${1} = --symlink ]]; then
577 symlink=${2}
578 shift 2
579 fi
580
561 local dir="$1" 581 local dir="$1"
582 local dest=/usr/share/doc/${PF}/html
583
584 # QA checks
562 585
563 java-pkg_check-phase install 586 java-pkg_check-phase install
564 587
565 [[ -z "${dir}" ]] && die "Must specify a directory!" 588 [[ -z "${dir}" ]] && die "Must specify a directory!"
566 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!" 589 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!"
590 if [[ ! -e "${dir}/index.html" ]]; then
591 local msg="No index.html in javadoc directory"
592 ewarn "${msg}"
593 is-java-strict && die "${msg}"
594 fi
595
596 if [[ -e ${D}/${dest}/api ]]; then
597 eerror "${dest} already exists. Will not overwrite."
598 die "${dest}"
599 fi
600
601 # Renaming to match our directory layout
567 602
568 local dir_to_install="${dir}" 603 local dir_to_install="${dir}"
569 if [[ "$(basename "${dir}")" != "api" ]]; then 604 if [[ "$(basename "${dir}")" != "api" ]]; then
570 dir_to_install="${T}/api" 605 dir_to_install="${T}/api"
571 # TODO use doins 606 # TODO use doins
572 cp -r "${dir}" "${dir_to_install}" || die "cp failed" 607 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
573 fi 608 fi
574 609
610 # Actual installation
611
575 java-pkg_dohtml -r ${dir_to_install} 612 java-pkg_dohtml -r "${dir_to_install}"
613
614 # Let's make a symlink to the directory we have everything else under
615 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
616
617 if [[ ${symlink} ]]; then
618 dosym ${dest}/{api,${symlink}} || die
619 fi
576} 620}
577 621
578# ------------------------------------------------------------------------------ 622# ------------------------------------------------------------------------------
579# @ebuild-function java-pkg_dosrc 623# @ebuild-function java-pkg_dosrc
580# 624#
819# @param $opt 863# @param $opt
820# --build-only - makes the jar(s) not added into package.env DEPEND line. 864# --build-only - makes the jar(s) not added into package.env DEPEND line.
821# (assumed automatically when called inside src_test) 865# (assumed automatically when called inside src_test)
822# --with-dependencies - get jars also from requested package's dependencies 866# --with-dependencies - get jars also from requested package's dependencies
823# transitively. 867# transitively.
868# --virtual - Packages passed to this function are to be handled as virtuals
869# and will not have individual jar dependencies recorded.
824# --into $dir - symlink jar(s) into $dir (must exist) instead of . 870# --into $dir - symlink jar(s) into $dir (must exist) instead of .
825# @param $1 - Package to get jars from. 871# @param $1 - Package to get jars from, or comma-separated list of packages in
872# case other parameters are not used.
826# @param $2 - jar from package. If not specified, all jars will be used. 873# @param $2 - jar from package. If not specified, all jars will be used.
827# @param $3 - When a single jar is specified, destination filename of the 874# @param $3 - When a single jar is specified, destination filename of the
828# symlink. Defaults to the name of the jar. 875# symlink. Defaults to the name of the jar.
829# ------------------------------------------------------------------------------ 876# ------------------------------------------------------------------------------
830# TODO could probably be cleaned up a little 877# TODO could probably be cleaned up a little
832 debug-print-function ${FUNCNAME} $* 879 debug-print-function ${FUNCNAME} $*
833 880
834 local build_only="" 881 local build_only=""
835 local destdir="." 882 local destdir="."
836 local deep="" 883 local deep=""
884 local virtual=""
837 885
838 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 886 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
839 887
840 while [[ "${1}" == --* ]]; do 888 while [[ "${1}" == --* ]]; do
841 if [[ "${1}" = "--build-only" ]]; then 889 if [[ "${1}" = "--build-only" ]]; then
842 build_only="true" 890 build_only="build"
843 elif [[ "${1}" = "--with-dependencies" ]]; then 891 elif [[ "${1}" = "--with-dependencies" ]]; then
844 deep="--with-dependencies" 892 deep="--with-dependencies"
893 elif [[ "${1}" = "--virtual" ]]; then
894 virtual="true"
845 elif [[ "${1}" = "--into" ]]; then 895 elif [[ "${1}" = "--into" ]]; then
846 destdir="${2}" 896 destdir="${2}"
847 shift 897 shift
848 else 898 else
849 die "java-pkg_jar-from called with unknown parameter: ${1}" 899 die "java-pkg_jar-from called with unknown parameter: ${1}"
861 local error_msg="There was a problem getting the classpath for ${target_pkg}." 911 local error_msg="There was a problem getting the classpath for ${target_pkg}."
862 local classpath 912 local classpath
863 classpath="$(java-config ${deep} --classpath=${target_pkg})" 913 classpath="$(java-config ${deep} --classpath=${target_pkg})"
864 [[ $? != 0 ]] && die ${error_msg} 914 [[ $? != 0 ]] && die ${error_msg}
865 915
916 # When we have commas this functions is called to bring jars from multiple
917 # packages. This affects recording of dependencencies performed later
918 # which expects one package only, so we do it here.
919 if [[ ${target_pkg} = *,* ]]; then
920 for pkg in ${target_pkg//,/ }; do
921 java-pkg_ensure-dep "${build_only}" "${pkg}"
922 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
923 done
924 # setting this disables further record-jar_ calls later
925 build_only="build"
926 else
866 java-pkg_ensure-dep "${build_only}" "${target_pkg}" 927 java-pkg_ensure-dep "${build_only}" "${target_pkg}"
928 fi
929
930 # Record the entire virtual as a dependency so that
931 # no jars are missed.
932 if [[ -z "${build_only}" && -n "${virtual}" ]]; then
933 java-pkg_record-jar_ "${target_pkg}"
934 # setting this disables further record-jars_ calls later
935 build_only="build"
936 fi
867 937
868 pushd ${destdir} > /dev/null \ 938 pushd ${destdir} > /dev/null \
869 || die "failed to change directory to ${destdir}" 939 || die "failed to change directory to ${destdir}"
870
871 # When we have commas this functions is called to bring jars from multiple
872 # packages. This affects recording of dependencencies because that syntax uses :
873 # if we don't change them to : gjl and java-config -d -p break
874 if [[ ${target_pkg} = *,* ]]; then
875 build_only="true"
876 java-pkg_record-jar_ ${target_pkg//,/:}
877 fi
878 940
879 local jar 941 local jar
880 for jar in ${classpath//:/ }; do 942 for jar in ${classpath//:/ }; do
881 local jar_name=$(basename "${jar}") 943 local jar_name=$(basename "${jar}")
882 if [[ ! -f "${jar}" ]] ; then 944 if [[ ! -f "${jar}" ]] ; then
945 debug-print-function ${FUNCNAME} $* 1007 debug-print-function ${FUNCNAME} $*
946 1008
947 local build_only="" 1009 local build_only=""
948 local deep="" 1010 local deep=""
949 1011
950 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1012 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
951 1013
952 while [[ "${1}" == --* ]]; do 1014 while [[ "${1}" == --* ]]; do
953 if [[ "${1}" = "--build-only" ]]; then 1015 if [[ "${1}" = "--build-only" ]]; then
954 build_only="true" 1016 build_only="build"
955 elif [[ "${1}" = "--with-dependencies" ]]; then 1017 elif [[ "${1}" = "--with-dependencies" ]]; then
956 deep="--with-dependencies" 1018 deep="--with-dependencies"
957 else 1019 else
958 die "java-pkg_jar-from called with unknown parameter: ${1}" 1020 die "java-pkg_jar-from called with unknown parameter: ${1}"
959 fi 1021 fi
966 local classpath pkgs="${1}" 1028 local classpath pkgs="${1}"
967 jars="$(java-config ${deep} --classpath=${pkgs})" 1029 jars="$(java-config ${deep} --classpath=${pkgs})"
968 [[ $? != 0 || -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed" 1030 [[ $? != 0 || -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed"
969 debug-print "${pkgs}:${jars}" 1031 debug-print "${pkgs}:${jars}"
970 1032
971 for pkg in "${pkgs//,/ }"; do 1033 for pkg in ${pkgs//,/ }; do
972 java-pkg_ensure-dep "${build_only}" "${pkg}" 1034 java-pkg_ensure-dep "${build_only}" "${pkg}"
973 done 1035 done
974 1036
975 if [[ -z "${classpath}" ]]; then 1037 if [[ -z "${classpath}" ]]; then
976 classpath="${jars}" 1038 classpath="${jars}"
978 classpath="${classpath}:${jars}" 1040 classpath="${classpath}:${jars}"
979 fi 1041 fi
980 1042
981 # Only record jars that aren't build-only 1043 # Only record jars that aren't build-only
982 if [[ -z "${build_only}" ]]; then 1044 if [[ -z "${build_only}" ]]; then
983 oldifs="${IFS}"
984 IFS=","
985 for pkg in ${pkgs}; do 1045 for pkg in ${pkgs//,/ }; do
986 java-pkg_record-jar_ "${pkg}" 1046 java-pkg_record-jar_ "${pkg}"
987 done 1047 done
988 IFS="${oldifs}"
989 fi 1048 fi
990 1049
991 echo "${classpath}" 1050 echo "${classpath}"
992} 1051}
993 1052
1005# @example-return 1064# @example-return
1006# /usr/share/xerces-2/lib/xml-apis.jar 1065# /usr/share/xerces-2/lib/xml-apis.jar
1007# 1066#
1008# @param $opt 1067# @param $opt
1009# --build-only - makes the jar not added into package.env DEPEND line. 1068# --build-only - makes the jar not added into package.env DEPEND line.
1069# --virtual - Packages passed to this function are to be handled as virtuals
1070# and will not have individual jar dependencies recorded.
1010# @param $1 - package to use 1071# @param $1 - package to use
1011# @param $2 - jar to get 1072# @param $2 - jar to get
1012# ------------------------------------------------------------------------------ 1073# ------------------------------------------------------------------------------
1013java-pkg_getjar() { 1074java-pkg_getjar() {
1014 debug-print-function ${FUNCNAME} $* 1075 debug-print-function ${FUNCNAME} $*
1015 1076
1016 local build_only="" 1077 local build_only=""
1078 local virtual=""
1017 1079
1018 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1080 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1019 1081
1020 while [[ "${1}" == --* ]]; do 1082 while [[ "${1}" == --* ]]; do
1021 if [[ "${1}" = "--build-only" ]]; then 1083 if [[ "${1}" = "--build-only" ]]; then
1022 build_only="true" 1084 build_only="build"
1085 elif [[ "${1}" == "--virtual" ]]; then
1086 virtual="true"
1023 else 1087 else
1024 die "java-pkg_jar-from called with unknown parameter: ${1}" 1088 die "java-pkg_jar-from called with unknown parameter: ${1}"
1025 fi 1089 fi
1026 shift 1090 shift
1027 done 1091 done
1036 local classpath 1100 local classpath
1037 classpath=$(java-config --classpath=${pkg}) 1101 classpath=$(java-config --classpath=${pkg})
1038 [[ $? != 0 ]] && die ${error_msg} 1102 [[ $? != 0 ]] && die ${error_msg}
1039 1103
1040 java-pkg_ensure-dep "${build_only}" "${pkg}" 1104 java-pkg_ensure-dep "${build_only}" "${pkg}"
1105
1106 # Record the package(Virtual) as a dependency and then set build_only
1107 # So that individual jars are not recorded.
1108 if [[ -n "${virtual}" ]]; then
1109 java-pkg_record-jar_ "${pkg}"
1110 build_only="true"
1111 fi
1041 1112
1042 for jar in ${classpath//:/ }; do 1113 for jar in ${classpath//:/ }; do
1043 if [[ ! -f "${jar}" ]] ; then 1114 if [[ ! -f "${jar}" ]] ; then
1044 die "Installation problem with jar ${jar} in ${pkg} - is it installed?" 1115 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1045 fi 1116 fi
1052 fi 1123 fi
1053 done 1124 done
1054 1125
1055 die "Could not find ${target_jar} in ${pkg}" 1126 die "Could not find ${target_jar} in ${pkg}"
1056 return 1 1127 return 1
1128}
1129
1130# ------------------------------------------------------------------------------
1131# @ebuild-function java-pkg_register-dependency
1132#
1133# Registers runtime dependency on a package, list of packages, or a single jar
1134# from a package, into package.env DEPEND line. Can only be called in
1135# src_install phase.
1136# Intended for binary packages where you don't need to symlink the jars or get
1137# their classpath during build. As such, the dependencies only need to be
1138# specified in ebuild's RDEPEND, and should be omitted in DEPEND.
1139#
1140# @param $1 - comma-separated list of packages, or a single package
1141# @param $2 - if param $1 is a single package, optionally specify the jar
1142# to depend on
1143#
1144# Example: Record the dependency on whole xerces-2 and xalan,
1145# java-pkg_register-dependency xerces-2,xalan
1146# Example: Record the dependency on ant.jar from ant-core
1147# java-pkg_register-dependency ant-core ant.jar
1148#
1149# Note: Passing both list of packages as the first parameter AND specifying the
1150# jar as the second is not allowed and will cause the function to die. We assume
1151# that there's more chance one passes such combination as a mistake, than that
1152# there are more packages providing identically named jar without class
1153# collisions.
1154# ------------------------------------------------------------------------------
1155java-pkg_register-dependency() {
1156 debug-print-function ${FUNCNAME} $*
1157
1158 java-pkg_check-phase install
1159
1160 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1161
1162 local pkgs="${1}"
1163 local jar="${2}"
1164
1165 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1166
1167 if [[ -z "${jar}" ]]; then
1168 for pkg in ${pkgs//,/ }; do
1169 java-pkg_ensure-dep runtime "${pkg}"
1170 java-pkg_record-jar_ "${pkg}"
1171 done
1172 else
1173 [[ ${pkgs} == *,* ]] && \
1174 die "${FUNCNAME} called with both package list and jar name"
1175 java-pkg_ensure-dep runtime "${pkgs}"
1176 java-pkg_record-jar_ "${pkgs}" "${jar}"
1177 fi
1178
1179 java-pkg_do_write_
1180}
1181
1182# ------------------------------------------------------------------------------
1183# @ebuild-function java-pkg_register-optional-dependency
1184#
1185# Registers optional runtime dependency on a package, list of packages, or a
1186# single jar from a package, into package.env OPTIONAL_DEPEND line. Can only be
1187# called in src_install phase.
1188# Intended for packages that can use other packages when those are in classpath.
1189# Will be put on classpath by launcher if they are installed. Typical case is
1190# JDBC implementations for various databases. It's better than having USE flag
1191# for each implementation triggering hard dependency.
1192#
1193# @param $1 - comma-separated list of packages, or a single package
1194# @param $2 - if param $1 is a single package, optionally specify the jar
1195# to depend on
1196#
1197# Example: Record the optional dependency on some jdbc providers
1198# java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1199#
1200# Note: Passing both list of packages as the first parameter AND specifying the
1201# jar as the second is not allowed and will cause the function to die. We assume
1202# that there's more chance one passes such combination as a mistake, than that
1203# there are more packages providing identically named jar without class
1204# collisions.
1205# ------------------------------------------------------------------------------
1206java-pkg_register-optional-dependency() {
1207 debug-print-function ${FUNCNAME} $*
1208
1209 java-pkg_check-phase install
1210
1211 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1212
1213 local pkgs="${1}"
1214 local jar="${2}"
1215
1216 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1217
1218 if [[ -z "${jar}" ]]; then
1219 for pkg in ${pkgs//,/ }; do
1220 java-pkg_record-jar_ --optional "${pkg}"
1221 done
1222 else
1223 [[ ${pkgs} == *,* ]] && \
1224 die "${FUNCNAME} called with both package list and jar name"
1225 java-pkg_record-jar_ --optional "${pkgs}" "${jar}"
1226 fi
1227
1228 java-pkg_do_write_
1229}
1230
1231# ------------------------------------------------------------------------------
1232# @ebuild-function java-pkg_register-environment-variable
1233#
1234# Register an arbitrary environment variable into package.env. The gjl launcher
1235# for this package or any package depending on this will export it into
1236# environement before executing java command.
1237# Must only be called in src_install phase.
1238#
1239# @param $1 - variable name
1240# @param $2 - variable value
1241# ------------------------------------------------------------------------------
1242JAVA_PKG_EXTRA_ENV="${T}/java-pkg-extra-env"
1243JAVA_PKG_EXTRA_ENV_VARS=""
1244java-pkg_register-environment-variable() {
1245 debug-print-function ${FUNCNAME} $*
1246
1247 java-pkg_check-phase install
1248
1249 [[ ${#} != 2 ]] && die "${FUNCNAME} takes two arguments"
1250
1251 echo "${1}=\"${2}\"" >> ${JAVA_PKG_EXTRA_ENV}
1252 JAVA_PKG_EXTRA_ENV_VARS="${JAVA_PKG_EXTRA_ENV_VARS} ${1}"
1253
1254 java-pkg_do_write_
1057} 1255}
1058 1256
1059# This function reads stdin, and based on that input, figures out how to 1257# This function reads stdin, and based on that input, figures out how to
1060# populate jars from the filesystem. 1258# populate jars from the filesystem.
1061# Need to figure out a good way of making use of this, ie be able to use a 1259# Need to figure out a good way of making use of this, ie be able to use a
1549 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true 1747 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1550 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true 1748 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1551 done 1749 done
1552 1750
1553 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then 1751 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1554 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks" 1752 java-pkg_announce-qa-violation --nodie "The ebuild DEPENDS on deprecated ant or ant-tasks"
1555 echo "all" 1753 echo "all"
1556 else 1754 else
1557 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant 1755 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1558 # so we deactivate all tasks that may be installed 1756 # so we deactivate all tasks that may be installed
1559 echo "none" 1757 echo "none"
1584 return 0 1782 return 0
1585 fi 1783 fi
1586} 1784}
1587 1785
1588# ------------------------------------------------------------------------------ 1786# ------------------------------------------------------------------------------
1787# @ebuild-function ejunit
1788#
1789# Junit wrapper function. Makes it easier to run the tests and checks for
1790# dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1791#
1792# Examples:
1793# ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1794# ejunit org.blinkenlights.jid3.test.AllTests
1795#
1796# @param $1 - -cp or -classpath
1797# @param $2 - classpath; junit and recorded dependencies get appended
1798# @param $@ - the rest of the parameters are passed to java
1799# ------------------------------------------------------------------------------
1800ejunit() {
1801 debug-print-function ${FUNCNAME} $*
1802
1803 local pkgs
1804 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1805 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1806 done
1807
1808 local cp=$(java-pkg_getjars --with-dependencies junit${pkgs})
1809 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1810 cp="${2}:${cp}"
1811 shift 2
1812 else
1813 cp=".:${cp}"
1814 fi
1815
1816 local runner=junit.textui.TestRunner
1817 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1818 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1819}
1820
1821# ------------------------------------------------------------------------------
1589# @section-end helper 1822# @section-end helper
1590# ------------------------------------------------------------------------------ 1823# ------------------------------------------------------------------------------
1591 1824
1592# ------------------------------------------------------------------------------ 1825# ------------------------------------------------------------------------------
1593# @section-begin build 1826# @section-begin build
1604# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS, 1837# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1605# variables: 1838# variables:
1606# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the 1839# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1607# gentoo.classpath property. Be sure to call 1840# gentoo.classpath property. Be sure to call
1608# java-ant_rewrite-classpath in src_unpack. 1841# java-ant_rewrite-classpath in src_unpack.
1842# JAVA_PKG_NO_BUNDLED_SEARCH - Don't search for bundled jars or class files
1609# *ANT_TASKS - used to determine ANT_TASKS before calling Ant. 1843# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1610# ------------------------------------------------------------------------------ 1844# ------------------------------------------------------------------------------
1611eant() { 1845eant() {
1612 debug-print-function ${FUNCNAME} $* 1846 debug-print-function ${FUNCNAME} $*
1613 1847
1614 # FIXME get this working 1848 if [[ ${EBUILD_PHASE} = compile ]]; then
1615# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1849 # Used to be done in hooks in java-ant-2.eclass but moved here so that we can
1616# java-pkg_announce-qa-violation \ 1850 # finally get rid of the hooks without breaking stuff
1617# "Using eant, but not depending on dev-java/ant or dev-java/ant-core" 1851
1852 [[ "${JAVA_ANT_IGNORE_SYSTEM_CLASSES}" && "${JAVA_PKG_BSFIX}" ]] \
1853 && java-ant_ignore-system-classes "${S}/build.xml"
1854
1855 if hasq java-ant-2 ${INHERITED}; then
1856 java-ant_bsfix
1857 fi
1858
1859 # eant can be called multiple times
1860 JAVA_PKG_BSFIX="off"
1861
1862 if [[ -z ${JAVA_PKG_NO_BUNDLED_SEARCH} ]] && is-java-strict; then
1863 echo "Searching for bundled jars:"
1864 java-pkg_find-normal-jars || echo "None found."
1865 echo "Searching for bundled classes (no output if none found):"
1866 find "${WORKDIR}" -name "*.class"
1867 echo "Search done."
1868 JAVA_PKG_NO_BUNDLED_SEARCH=true # eant can be called many times
1869 fi
1618# fi 1870 fi
1619 1871
1620 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then 1872 if ! hasq java-ant-2 ${INHERITED}; then
1621 local msg="You should inherit java-ant-2 when using eant" 1873 local msg="You should inherit java-ant-2 when using eant"
1622 java-pkg_announce-qa-violation ${msg} 1874 java-pkg_announce-qa-violation "${msg}"
1623 die ${msg}
1624 fi 1875 fi
1625 1876
1626 local antflags="-Dnoget=true -Dmaven.mode.offline=true" 1877 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1627 1878
1628 java-pkg_init-compiler_ 1879 java-pkg_init-compiler_
1629 local compiler="${GENTOO_COMPILER}" 1880 local compiler="${GENTOO_COMPILER}"
1630 1881
1631 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1882 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1632
1633 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})" 1883 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1634 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1884 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1635 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1885 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1636 fi 1886 fi
1637 1887
1643 # java-config -p 1893 # java-config -p
1644 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1894 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1645 if [[ -n ${build_compiler_deps} ]]; then 1895 if [[ -n ${build_compiler_deps} ]]; then
1646 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})" 1896 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1647 fi 1897 fi
1648 fi
1649
1650 if is-java-strict; then
1651 einfo "Disabling system classpath for ant"
1652 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1653 fi 1898 fi
1654 1899
1655 for arg in "${@}"; do 1900 for arg in "${@}"; do
1656 if [[ ${arg} = -lib ]]; then 1901 if [[ ${arg} = -lib ]]; then
1657 if is-java-strict; then 1902 if is-java-strict; then
1666 echo "more info." 1911 echo "more info."
1667 fi 1912 fi
1668 fi 1913 fi
1669 done 1914 done
1670 1915
1916 # we use this in src_* so we run ant from /
1671 if has_version ">=dev-java/ant-core-1.7.0"; then 1917 if ROOT=/ has_version ">=dev-java/ant-core-1.7.0"; then
1672 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly 1918 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1673 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}" 1919 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1674 1920
1675 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set 1921 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1676 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}" 1922 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1699 1945
1700 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug" 1946 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1701 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q" 1947 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1702 1948
1703 local gcp="${EANT_GENTOO_CLASSPATH}" 1949 local gcp="${EANT_GENTOO_CLASSPATH}"
1950 local getjarsarg=""
1704 1951
1705 if [[ ${EBUILD_PHASE} = "test" ]]; then 1952 if [[ ${EBUILD_PHASE} = "test" ]]; then
1706 antflags="${antflags} -DJunit.present=true" 1953 antflags="${antflags} -DJunit.present=true"
1707 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit" 1954 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit"
1955 getjarsarg="--with-dependencies"
1708 fi 1956 fi
1709 1957
1710 local cp 1958 local cp
1711 1959
1712 for atom in ${gcp}; do 1960 for atom in ${gcp}; do
1713 cp="${cp}:$(java-pkg_getjars ${atom})" 1961 cp="${cp}:$(java-pkg_getjars ${getjarsarg} ${atom})"
1714 done 1962 done
1715 1963
1716 if [[ ${cp} ]]; then 1964 if [[ ${cp} ]]; then
1717 # It seems ant does not like single quotes around ${cp} 1965 # It seems ant does not like single quotes around ${cp}
1718 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\"" 1966 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\""
1719 fi 1967 fi
1720 1968
1721 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1969 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1722 debug-print "Calling ant: ${antflags} ${@}" 1970 debug-print "Calling ant (GENTOO_VM: ${GENTOO_VM}): ${antflags} ${@}"
1723 ant ${antflags} "${@}" || die "eant failed" 1971 ant ${antflags} "${@}" || die "eant failed"
1724
1725} 1972}
1726 1973
1727# ------------------------------------------------------------------------------ 1974# ------------------------------------------------------------------------------
1728# @ebuild-function ejavac 1975# @ebuild-function ejavac
1729# 1976#
1824# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will 2071# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
1825# call it during each of the phases of the merge process. 2072# call it during each of the phases of the merge process.
1826# 2073#
1827# ----------------------------------------------------------------------------- 2074# -----------------------------------------------------------------------------
1828java-pkg_init() { 2075java-pkg_init() {
2076 debug-print-function ${FUNCNAME} $*
1829 unset JAVAC 2077 unset JAVAC
1830 unset JAVA_HOME 2078 unset JAVA_HOME
1831 2079
1832 # People do all kinds of weird things. 2080 # People do all kinds of weird things.
1833 # http://forums.gentoo.org/viewtopic-p-3943166.html 2081 # http://forums.gentoo.org/viewtopic-p-3943166.html
1841 ewarn "make.conf for example) to silence this warning or" 2089 ewarn "make.conf for example) to silence this warning or"
1842 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it." 2090 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
1843 fi 2091 fi
1844 2092
1845 if [[ -z ${accept} ]]; then 2093 if [[ -z ${accept} ]]; then
2094 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2095 # -version output
1846 unset _JAVA_OPTIONS 2096 unset _JAVA_OPTIONS
1847 # phase hooks make this run many times without this 2097 # phase hooks make this run many times without this
1848 I_WANT_GLOBAL_JAVA_OPTIONS="true" 2098 I_WANT_GLOBAL_JAVA_OPTIONS="true"
1849 fi 2099 fi
1850 2100
2101 if java-pkg_func-exists ant_src_unpack; then
2102 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2103 fi
2104
1851 java-pkg_init_paths_ 2105 java-pkg_init_paths_
1852 java-pkg_switch-vm 2106 java-pkg_switch-vm
1853 PATH=${JAVA_HOME}/bin:${PATH} 2107 PATH=${JAVA_HOME}/bin:${PATH}
1854 2108
1855 # TODO we will probably want to set JAVAC and JAVACFLAGS 2109 # TODO we will probably want to set JAVAC and JAVACFLAGS
1856 2110
1857 # Do some QA checks 2111 # Do some QA checks
1858 java-pkg_check-jikes 2112 java-pkg_check-jikes
2113
2114 # Can't use unset here because Portage does not save the unset
2115 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
1859 2116
1860 # When users have crazy classpaths some packages can fail to compile. 2117 # When users have crazy classpaths some packages can fail to compile.
1861 # and everything should work with empty CLASSPATH. 2118 # and everything should work with empty CLASSPATH.
1862 # This also helps prevent unexpected dependencies on random things 2119 # This also helps prevent unexpected dependencies on random things
1863 # from the CLASSPATH. 2120 # from the CLASSPATH.
1864 unset CLASSPATH 2121 export CLASSPATH=
1865 2122
1866 # Unset external ANT_ stuff 2123 # Unset external ANT_ stuff
1867 unset ANT_TASKS 2124 export ANT_TASKS=
1868 unset ANT_OPTS 2125 export ANT_OPTS=
1869} 2126}
1870 2127
1871# ------------------------------------------------------------------------------ 2128# ------------------------------------------------------------------------------
1872# @function-internal java-pkg-init-compiler_ 2129# @function-internal java-pkg-init-compiler_
1873# 2130#
1995 fi 2252 fi
1996 2253
1997 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}" 2254 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
1998 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/" 2255 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
1999 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env" 2256 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2257 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2258 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2000 2259
2001 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib" 2260 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2002 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}" 2261 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2003 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps" 2262 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2004 2263
2017# Writes the package.env out to disk. 2276# Writes the package.env out to disk.
2018# 2277#
2019# ------------------------------------------------------------------------------ 2278# ------------------------------------------------------------------------------
2020# TODO change to do-write, to match everything else 2279# TODO change to do-write, to match everything else
2021java-pkg_do_write_() { 2280java-pkg_do_write_() {
2281 debug-print-function ${FUNCNAME} $*
2022 java-pkg_init_paths_ 2282 java-pkg_init_paths_
2023 # Create directory for package.env 2283 # Create directory for package.env
2024 dodir "${JAVA_PKG_SHAREPATH}" 2284 dodir "${JAVA_PKG_SHAREPATH}"
2025 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 2285 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2286 "${JAVA_PKG_DEPEND_FILE}" || -f \
2287 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2026 # Create package.env 2288 # Create package.env
2027 ( 2289 (
2028 echo "DESCRIPTION=\"${DESCRIPTION}\"" 2290 echo "DESCRIPTION=\"${DESCRIPTION}\""
2029 echo "GENERATION=\"2\"" 2291 echo "GENERATION=\"2\""
2030 2292
2031 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\"" 2293 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2032 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 2294 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2033 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 2295 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2034 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 2296 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2297 && echo "DEPEND=\"$(cat "${JAVA_PKG_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2298 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2299 && echo "OPTIONAL_DEPEND=\"$(cat "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2035 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 2300 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2036 ) > "${JAVA_PKG_ENV}" 2301 ) > "${JAVA_PKG_ENV}"
2037 2302
2038 # register target/source 2303 # register target/source
2039 local target="$(java-pkg_get-target)" 2304 local target="$(java-pkg_get-target)"
2050 2315
2051 2316
2052 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}" 2317 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2053 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}" 2318 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2054 2319
2320 # extra env variables
2321 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2322 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2323 # nested echo to remove leading/trailing spaces
2324 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2325 >> "${JAVA_PKG_ENV}" || die
2326 fi
2327
2055 # Strip unnecessary leading and trailing colons 2328 # Strip unnecessary leading and trailing colons
2056 # TODO try to cleanup if possible 2329 # TODO try to cleanup if possible
2057 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 2330 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2331 else
2332 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2333 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2334 debug-print "write package.env."
2058 fi 2335 fi
2059} 2336}
2060 2337
2061# ------------------------------------------------------------------------------ 2338# ------------------------------------------------------------------------------
2062# @internal-function java-pkg_record-jar_ 2339# @internal-function java-pkg_record-jar_
2063# 2340#
2064# Record a dependency to the package.env 2341# Record an (optional) dependency to the package.env
2065# 2342# @param --optional - record dependency as optional
2343# @param $1 - package to record
2344# @param $2 - (optional) jar of package to record
2066# ------------------------------------------------------------------------------ 2345# ------------------------------------------------------------------------------
2067JAVA_PKG_DEPEND="${T}/java-pkg-depend" 2346JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2347JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2068 2348
2069java-pkg_record-jar_() { 2349java-pkg_record-jar_() {
2070 debug-print-function ${FUNCNAME} $* 2350 debug-print-function ${FUNCNAME} $*
2351
2352 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2353 if [[ "${1}" == "--optional" ]]; then
2354 depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"
2355 shift
2356 fi
2071 2357
2072 local pkg=${1} jar=${2} append 2358 local pkg=${1} jar=${2} append
2073 if [[ -z "${jar}" ]]; then 2359 if [[ -z "${jar}" ]]; then
2074 append="${pkg}" 2360 append="${pkg}"
2075 else 2361 else
2076 append="$(basename ${jar})@${pkg}" 2362 append="$(basename ${jar})@${pkg}"
2077 fi 2363 fi
2078 2364
2079 echo ${append} >> ${JAVA_PKG_DEPEND} 2365 echo "${append}" >> "${depend_file}"
2080} 2366}
2081 2367
2082# ------------------------------------------------------------------------------ 2368# ------------------------------------------------------------------------------
2083# @internal-function java-pkg_append_ 2369# @internal-function java-pkg_append_
2084# 2370#
2144# 2430#
2145# ------------------------------------------------------------------------------ 2431# ------------------------------------------------------------------------------
2146java-pkg_setup-vm() { 2432java-pkg_setup-vm() {
2147 debug-print-function ${FUNCNAME} $* 2433 debug-print-function ${FUNCNAME} $*
2148 2434
2435 export LANG="C" LC_ALL="C"
2436
2149 local vendor="$(java-pkg_get-vm-vendor)" 2437 local vendor="$(java-pkg_get-vm-vendor)"
2150 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then 2438 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2151 addpredict "/dev/random" 2439 addpredict "/dev/random"
2152 elif [[ "${vendor}" == "ibm" ]]; then 2440 elif [[ "${vendor}" == "ibm" ]]; then
2153 addpredict "/proc/self/maps" 2441 addpredict "/proc/self/maps"
2154 addpredict "/proc/cpuinfo" 2442 addpredict "/proc/cpuinfo"
2155 export LANG="C" LC_ALL="C"
2156 elif [[ "${vendor}" == "jrockit" ]]; then 2443 elif [[ "${vendor}" == "jrockit" ]]; then
2157 addpredict "/proc/cpuinfo" 2444 addpredict "/proc/cpuinfo"
2158 fi 2445 fi
2159} 2446}
2160 2447
2264 2551
2265 #TODO If you know a better solution let us know. 2552 #TODO If you know a better solution let us know.
2266 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2553 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2267 2554
2268 local tann="${T}/announced-vm" 2555 local tann="${T}/announced-vm"
2556 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2557 # if people have for example modified eclasses some where
2269 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2558 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2270 # Add a check for setup/preinst phase... to avoid duplicate outputs
2271 # for when FEATURES=buildpkg
2272 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
2273 then
2274 einfo "Using: $(java-config -f)" 2559 einfo "Using: $(java-config -f)"
2275 [[ ! -f "${tann}" ]] && touch "${tann}" 2560 [[ ! -f "${tann}" ]] && touch "${tann}"
2276 fi
2277 fi 2561 fi
2278 2562
2279 else 2563 else
2280 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!" 2564 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2281 fi 2565 fi
2345 2629
2346# ---------------------------------------------------------------------------- 2630# ----------------------------------------------------------------------------
2347# @internal-function java-pkg_ensure-dep 2631# @internal-function java-pkg_ensure-dep
2348# Check that a package being used in jarfrom, getjars and getjar is contained 2632# Check that a package being used in jarfrom, getjars and getjar is contained
2349# within DEPEND or RDEPEND. 2633# within DEPEND or RDEPEND.
2350# @param $1 - Is the package a runtime dependency 2634# @param $1 - empty - check both vars; "runtime" or "build" - check only
2635# RDEPEND, resp. DEPEND
2351# @param $2 - Package name and slot. 2636# @param $2 - Package name and slot.
2352 2637
2353java-pkg_ensure-dep() { 2638java-pkg_ensure-dep() {
2354 debug-print-function ${FUNCNAME} $* 2639 debug-print-function ${FUNCNAME} $*
2355 2640
2356 local build_only="${1}" 2641 local limit_to="${1}"
2357 local target_pkg="${2}" 2642 local target_pkg="${2}"
2358 local dev_error="" 2643 local dev_error=""
2359 2644
2360 local stripped_pkg=$(echo "${target_pkg}" | sed \ 2645 local stripped_pkg=$(echo "${target_pkg}" | sed \
2361 's/-[0-9]*\(\.[0-9]\)*$//') 2646 's/-[0-9]*\(\.[0-9]\)*$//')
2362 2647
2648 debug-print "Matching against: ${stripped_pkg}"
2649
2363 if [[ ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then 2650 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then
2364 dev_error="The ebuild is attempting to use ${target_pkg} that is not" 2651 dev_error="The ebuild is attempting to use ${target_pkg} that is not"
2365 dev_error="${dev_error} declared in DEPEND." 2652 dev_error="${dev_error} declared in DEPEND."
2366 if is-java-strict; then 2653 if is-java-strict; then
2654 eerror "${dev_error}"
2367 die "${dev_error}" 2655 die "${dev_error}"
2368 else 2656 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2369 eerror "${dev_error}" 2657 eerror "${dev_error}"
2370 einfo "Because you have this package installed the package will" 2658 elog "Because you have this package installed the package will"
2371 einfo "build without problems, but please report this to" 2659 elog "build without problems, but please report this to"
2372 einfo "http://bugs.gentoo.org" 2660 elog "http://bugs.gentoo.org"
2373 fi
2374 fi 2661 fi
2662 fi
2375 2663
2664 if [[ ${limit_to} != build ]]; then
2376 if [[ -z ${build_only} && ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then 2665 if [[ ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then
2666 if [[ ! ( ${PDEPEND} =~ "${stripped_pkg}" ) ]]; then
2377 dev_error="The ebuild is attempting to use ${target_pkg}," 2667 dev_error="The ebuild is attempting to use ${target_pkg},"
2378 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND." 2668 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND"
2669 dev_error="${dev_error} or PDEPEND."
2379 if is-java-strict; then 2670 if is-java-strict; then
2380 die "${error}"
2381 else
2382 eerror "${dev_error}" 2671 eerror "${dev_error}"
2383 einfo "Because you have this package installed the package will" 2672 die "${dev_error}"
2384 einfo "build without problems, but please report this to" 2673 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2674 eerror "${dev_error}"
2675 elog "The package will build without problems, but may fail to run"
2676 elog "if you don't have ${target_pkg} installed, so please report"
2385 einfo "http://bugs.gentoo.org" 2677 elog "this to http://bugs.gentoo.org"
2678 fi
2679 fi
2386 fi 2680 fi
2387 fi 2681 fi
2388} 2682}
2389 2683
2390# ------------------------------------------------------------------------------ 2684# ------------------------------------------------------------------------------
2391# @section-end internal 2685# @section-end internal
2392# ------------------------------------------------------------------------------ 2686# ------------------------------------------------------------------------------
2393 2687
2394java-pkg_check-phase() { 2688java-pkg_check-phase() {
2395 local phase=${1} 2689 local phase=${1}
2396 local funcname=${2} 2690 local funcname=${FUNCNAME[1]}
2397 if is-java-strict && [[ ${EBUILD_PHASE} != ${phase} ]]; then 2691 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2398 java-pkg_announce-qa-violation \
2399 "${funcname} used outside of src_${phase}" 2692 local msg="${funcname} used outside of src_${phase}"
2693 java-pkg_announce-qa-violation "${msg}"
2400 fi 2694 fi
2401} 2695}
2402 2696
2403java-pkg_check-versioned-jar() { 2697java-pkg_check-versioned-jar() {
2404 local jar=${1} 2698 local jar=${1}
2413 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE" 2707 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2414 fi 2708 fi
2415} 2709}
2416 2710
2417java-pkg_announce-qa-violation() { 2711java-pkg_announce-qa-violation() {
2418 if is-java-strict; then 2712 local nodie
2713 if [[ ${1} == "--nodie" ]]; then
2714 nodie="true"
2715 shift
2716 fi
2419 echo "Java QA Notice: $@" >&2 2717 echo "Java QA Notice: $@" >&2
2420 increment-qa-violations 2718 increment-qa-violations
2421 fi 2719 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2422} 2720}
2423 2721
2424increment-qa-violations() { 2722increment-qa-violations() {
2425 let "JAVA_PKG_QA_VIOLATIONS+=1" 2723 let "JAVA_PKG_QA_VIOLATIONS+=1"
2426 export JAVA_PKG_QA_VIOLATIONS 2724 export JAVA_PKG_QA_VIOLATIONS

Legend:
Removed from v.1.70  
changed lines
  Added in v.1.101

  ViewVC Help
Powered by ViewVC 1.1.20