gentoo-x86/eclass/haskell-cabal.eclass

# Copyright 1999-2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.12 2007/07/27 09:09:20 kolmodin Exp $
#
# Original authors: Andres Loeh <kosmikus@gentoo.org>
#                   Duncan Coutts <dcoutts@gentoo.org>
# Maintained by: Haskell herd <haskell@gentoo.org>
#
# This eclass is for packages that make use of the
# Haskell Common Architecture for Building Applications
# and Libraries (cabal).
#
# Basic instructions:
#
# Before inheriting the eclass, set CABAL_FEATURES to
# reflect the tools and features that the package makes
# use of.
#
# Currently supported features:
#   haddock    --  for documentation generation
#   alex       --  lexer/scanner generator
#   happy      --  parser generator
#   c2hs       --  C interface generator
#   cpphs      --  C preprocessor clone written in Haskell
#   profile    --  if package supports to build profiling-enabled libraries
#   bootstrap  --  only used for the cabal package itself
#   bin        --  the package installs binaries
#   lib        --  the package installs libraries
#
# Dependencies on other cabal packages have to be specified
# correctly.
#
# Cabal libraries should usually be SLOTted with "${PV}".
#
# Many Cabal packages require S to be manually set.
#
# Conforming Cabal packages don't require any function definitions
# in the ebuild.
#
# Special flags to Cabal Configure can now be set by using
# CABAL_CONFIGURE_FLAGS

inherit ghc-package multilib


for feature in ${CABAL_FEATURES}; do
        case ${feature} in
                haddock)   CABAL_USE_HADDOCK=yes;;
                alex)      CABAL_USE_ALEX=yes;;
                happy)     CABAL_USE_HAPPY=yes;;
                c2hs)      CABAL_USE_C2HS=yes;;
                cpphs)     CABAL_USE_CPPHS=yes;;
                profile)   CABAL_USE_PROFILE=yes;;
                bootstrap) CABAL_BOOTSTRAP=yes;;
                bin)       CABAL_HAS_BINARIES=yes;;
                lib)       CABAL_HAS_LIBRARIES=yes;;
                *) CABAL_UNKNOWN="${CABAL_UNKNOWN} ${feature}";;
        esac
done

if [[ -n "${CABAL_USE_HADDOCK}" ]]; then
        IUSE="${IUSE} doc"
        DEPEND="${DEPEND} doc? ( dev-haskell/haddock )"
        cabalconf="${cabalconf} --with-haddock=/usr/bin/haddock"
fi

if [[ -n "${CABAL_USE_ALEX}" ]]; then
        DEPEND="${DEPEND} dev-haskell/alex"
        cabalconf="${cabalconf} --with-alex=/usr/bin/alex"
fi

if [[ -n "${CABAL_USE_HAPPY}" ]]; then
        DEPEND="${DEPEND} dev-haskell/happy"
        cabalconf="${cabalconf} --with-happy=/usr/bin/happy"
fi

if [[ -n "${CABAL_USE_C2HS}" ]]; then
        DEPEND="${DEPEND} dev-haskell/c2hs"
        cabalconf="${cabalconf} --with-c2hs=/usr/bin/c2hs"
fi

if [[ -n "${CABAL_USE_CPPHS}" ]]; then
        DEPEND="${DEPEND} dev-haskell/cpphs"
        cabalconf="${cabalconf} --with-cpphs=/usr/bin/cpphs"
fi

if [[ -n "${CABAL_USE_PROFILE}" ]]; then
        IUSE="${IUSE} profile"
fi

# We always use a standalone version of Cabal, rather than the one that comes
# with GHC. But of course we can't depend on cabal when building cabal itself.
CABAL_MIN_VERSION=1.1.4
if [[ -z "${CABAL_BOOTSTRAP}" ]]; then
        DEPEND="${DEPEND} >=dev-haskell/cabal-${CABAL_MIN_VERSION}"
fi

# Libraries require GHC to be installed.
if [[ -n "${CABAL_HAS_LIBRARIES}" ]]; then
        RDEPEND="${RDEPEND} dev-lang/ghc"
fi

cabal-bootstrap() {
        local setupmodule
        local cabalversion
        if [[ -f "${S}/Setup.lhs" ]]; then
                setupmodule="${S}/Setup.lhs"
        else
                if [[ -f "${S}/Setup.hs" ]]; then
                        setupmodule="${S}/Setup.hs"
                else
                        die "No Setup.lhs or Setup.hs found"
                fi
        fi

        # We build the setup program using the latest version of
        # cabal that we have installed
        cabalversion=$(ghc-bestcabalversion)
        einfo "Using ${cabalversion}."
        $(ghc-getghc) -package "${cabalversion}" --make "${setupmodule}" -o setup \
                || die "compiling ${setupmodule} failed"
}

cabal-haddock() {
        ./setup haddock || die "setup haddock failed"
}

cabal-configure() {
        if [[ -n "${CABAL_USE_PROFILE}" ]] && use profile; then
                cabalconf="${cabalconf} --enable-library-profiling"
        fi
        # Building GHCi libs on ppc64 causes "TOC overflow".
        if use ppc64; then
                cabalconf="${cabalconf} --disable-library-for-ghci"
        fi

        # Note: with Cabal-1.1.6.x we still do not have enough control
        # to put the docs into the right place. They're currently going
        # into                  /usr/share/${P}/ghc-x.y/doc/
        # rather than   /usr/share/doc/${PF}/
        # Because we can only set the datadir, not the docdir.

        ./setup configure \
                --ghc --prefix=/usr \
                --with-compiler="$(ghc-getghc)" \
                --with-hc-pkg="$(ghc-getghcpkg)" \
                --prefix=/usr \
                --libdir=/usr/$(get_libdir) \
                --libsubdir=${P}/ghc-$(ghc-version) \
                --datadir=/usr/share/ \
                --datasubdir=${P}/ghc-$(ghc-version) \
                ${cabalconf} \
                ${CABAL_CONFIGURE_FLAGS} \
                "$@" || die "setup configure failed"
}

cabal-build() {
        ./setup build \
                || die "setup build failed"
}

cabal-copy() {
        ./setup copy \
                --destdir="${D}" \
                || die "setup copy failed"

        # cabal is a bit eager about creating dirs,
        # so remove them if they are empty
        rmdir "${D}/usr/bin" 2> /dev/null

        # GHC 6.4 has a bug in get/setPermission and Cabal 1.1.1 has
        # no workaround.
        # set the +x permission on executables
        if [[ -d "${D}/usr/bin" ]] ; then
                chmod +x "${D}/usr/bin/"*
        fi
        # TODO: do we still need this?
}

cabal-pkg() {
        # This does not actually register since we're using true instead
        # of ghc-pkg. So it just leaves the .installed-pkg-config and we can
        # register that ourselves (if it exists).
        local result
        local err

        if [[ -n ${CABAL_HAS_LIBRARIES} ]]; then
                sed -i "s|$(ghc-getghcpkg)|$(type -P true)|" .setup-config
                ./setup register || die "setup register failed"
                if [[ -f .installed-pkg-config ]]; then
                        ghc-setup-pkg .installed-pkg-config
                        ghc-install-pkg
                else
                        die "setup register has not generated a package configuration file"
                fi
        fi
}

# Some cabal libs are bundled along with some versions of ghc
# eg filepath-1.0 comes with ghc-6.6.1
# by putting CABAL_CORE_LIB_GHC_PV="6.6.1" in an ebuild we are declaring that
# when building with this version of ghc, the ebuild is a dummy that is it will
# install no files since the package is already included with ghc.
# However portage still records the dependency and we can upgrade the package
# to a later one that's not included with ghc.
# You can also put a space separated list, eg CABAL_CORE_LIB_GHC_PV="6.6 6.6.1".
cabal-is-dummy-lib() {
        for version in ${CABAL_CORE_LIB_GHC_PV[*]}; do
                [[ "$(ghc-version)" == "$version" ]] && return 0
        done
        return 1
}

# exported function: check if cabal is correctly installed for
# the currently active ghc (we cannot guarantee this with portage)
haskell-cabal_pkg_setup() {
        ghc-package_pkg_setup
        if [[ -z "${CABAL_BOOTSTRAP}" ]] && ! ghc-sanecabal "${CABAL_MIN_VERSION}"; then
                eerror "The package dev-haskell/cabal is not correctly installed for"
                eerror "the currently active version of ghc ($(ghc-version)). Please"
                eerror "run ghc-updater or re-emerge dev-haskell/cabal."
                die "cabal is not correctly installed"
        fi
        if [[ -z "${CABAL_HAS_BINARIES}" ]] && [[ -z "${CABAL_HAS_LIBRARIES}" ]]; then
                eerror "QA: Neither bin nor lib are in CABAL_FEATURES."
        fi
        if [[ -n "${CABAL_UNKNOWN}" ]]; then
                ewarn "Unknown entry in CABAL_FEATURES: ${CABAL_UNKNONW}"
        fi
        if cabal-is-dummy-lib; then
                einfo "${P} is included in ghc-${CABAL_CORE_LIB_GHC_PV}, nothing to install."
        fi
}

# exported function: cabal-style bootstrap configure and compile
cabal_src_compile() {
        if ! cabal-is-dummy-lib; then
                cabal-bootstrap
                cabal-configure
                cabal-build

                if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                        cabal-haddock
                fi
        fi
}
haskell-cabal_src_compile() {
        cabal_src_compile
}

# exported function: cabal-style copy and register
cabal_src_install() {
        if cabal-is-dummy-lib; then
                # create a dummy local package conf file for the sake of ghc-updater
                dodir "$(ghc-confdir)"
                echo '[]' > "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
        else
                cabal-copy
                cabal-pkg

                if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                        local cabalversion=$(ghc-extractportageversion dev-haskell/cabal)
                        if ! version_is_at_least "1.1.6" "${cabalversion}"; then
                                dohtml -r dist/doc/html/*
                        fi
                fi
        fi
}
haskell-cabal_src_install() {
        cabal_src_install
}

EXPORT_FUNCTIONS pkg_setup src_compile src_install
1	dcoutts	1.4	# Copyright 1999-2006 Gentoo Foundation
2	kosmikus	1.1	# Distributed under the terms of the GNU General Public License v2
3	kolmodin	1.13	# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.12 2007/07/27 09:09:20 kolmodin Exp $
4	kosmikus	1.1	#
5			# Original authors: Andres Loeh <kosmikus@gentoo.org>
6			# Duncan Coutts <dcoutts@gentoo.org>
7			# Maintained by: Haskell herd <haskell@gentoo.org>
8			#
9			# This eclass is for packages that make use of the
10			# Haskell Common Architecture for Building Applications
11			# and Libraries (cabal).
12			#
13			# Basic instructions:
14			#
15			# Before inheriting the eclass, set CABAL_FEATURES to
16			# reflect the tools and features that the package makes
17			# use of.
18			#
19			# Currently supported features:
20			# haddock -- for documentation generation
21			# alex -- lexer/scanner generator
22			# happy -- parser generator
23			# c2hs -- C interface generator
24			# cpphs -- C preprocessor clone written in Haskell
25			# profile -- if package supports to build profiling-enabled libraries
26			# bootstrap -- only used for the cabal package itself
27	dcoutts	1.3	# bin -- the package installs binaries
28			# lib -- the package installs libraries
29	kosmikus	1.1	#
30			# Dependencies on other cabal packages have to be specified
31			# correctly.
32			#
33			# Cabal libraries should usually be SLOTted with "${PV}".
34			#
35			# Many Cabal packages require S to be manually set.
36			#
37			# Conforming Cabal packages don't require any function definitions
38			# in the ebuild.
39	kosmikus	1.8	#
40			# Special flags to Cabal Configure can now be set by using
41			# CABAL_CONFIGURE_FLAGS
42	kosmikus	1.1
43	dcoutts	1.11	inherit ghc-package multilib
44	kosmikus	1.1
45
46			for feature in ${CABAL_FEATURES}; do
47			case ${feature} in
48			haddock) CABAL_USE_HADDOCK=yes;;
49			alex) CABAL_USE_ALEX=yes;;
50			happy) CABAL_USE_HAPPY=yes;;
51			c2hs) CABAL_USE_C2HS=yes;;
52			cpphs) CABAL_USE_CPPHS=yes;;
53			profile) CABAL_USE_PROFILE=yes;;
54			bootstrap) CABAL_BOOTSTRAP=yes;;
55	dcoutts	1.3	bin) CABAL_HAS_BINARIES=yes;;
56			lib) CABAL_HAS_LIBRARIES=yes;;
57			*) CABAL_UNKNOWN="${CABAL_UNKNOWN} ${feature}";;
58	kosmikus	1.1	esac
59			done
60
61			if [[ -n "${CABAL_USE_HADDOCK}" ]]; then
62			IUSE="${IUSE} doc"
63			DEPEND="${DEPEND} doc? ( dev-haskell/haddock )"
64			cabalconf="${cabalconf} --with-haddock=/usr/bin/haddock"
65			fi
66
67			if [[ -n "${CABAL_USE_ALEX}" ]]; then
68			DEPEND="${DEPEND} dev-haskell/alex"
69			cabalconf="${cabalconf} --with-alex=/usr/bin/alex"
70			fi
71
72			if [[ -n "${CABAL_USE_HAPPY}" ]]; then
73			DEPEND="${DEPEND} dev-haskell/happy"
74			cabalconf="${cabalconf} --with-happy=/usr/bin/happy"
75			fi
76
77			if [[ -n "${CABAL_USE_C2HS}" ]]; then
78			DEPEND="${DEPEND} dev-haskell/c2hs"
79			cabalconf="${cabalconf} --with-c2hs=/usr/bin/c2hs"
80			fi
81
82			if [[ -n "${CABAL_USE_CPPHS}" ]]; then
83			DEPEND="${DEPEND} dev-haskell/cpphs"
84			cabalconf="${cabalconf} --with-cpphs=/usr/bin/cpphs"
85			fi
86
87			if [[ -n "${CABAL_USE_PROFILE}" ]]; then
88			IUSE="${IUSE} profile"
89			fi
90
91			# We always use a standalone version of Cabal, rather than the one that comes
92			# with GHC. But of course we can't depend on cabal when building cabal itself.
93	dcoutts	1.11	CABAL_MIN_VERSION=1.1.4
94	kosmikus	1.1	if [[ -z "${CABAL_BOOTSTRAP}" ]]; then
95	dcoutts	1.11	DEPEND="${DEPEND} >=dev-haskell/cabal-${CABAL_MIN_VERSION}"
96	kosmikus	1.1	fi
97
98	dcoutts	1.3	# Libraries require GHC to be installed.
99			if [[ -n "${CABAL_HAS_LIBRARIES}" ]]; then
100	dcoutts	1.11	RDEPEND="${RDEPEND} dev-lang/ghc"
101	dcoutts	1.3	fi
102	kosmikus	1.1
103			cabal-bootstrap() {
104			local setupmodule
105			local cabalversion
106			if [[ -f "${S}/Setup.lhs" ]]; then
107			setupmodule="${S}/Setup.lhs"
108			else
109			if [[ -f "${S}/Setup.hs" ]]; then
110			setupmodule="${S}/Setup.hs"
111			else
112			die "No Setup.lhs or Setup.hs found"
113			fi
114			fi
115
116			# We build the setup program using the latest version of
117			# cabal that we have installed
118			cabalversion=$(ghc-bestcabalversion)
119			einfo "Using ${cabalversion}."
120			$(ghc-getghc) -package "${cabalversion}" --make "${setupmodule}" -o setup \
121			\|\| die "compiling ${setupmodule} failed"
122			}
123
124			cabal-haddock() {
125			./setup haddock \|\| die "setup haddock failed"
126			}
127
128			cabal-configure() {
129			if [[ -n "${CABAL_USE_PROFILE}" ]] && use profile; then
130	dcoutts	1.2	cabalconf="${cabalconf} --enable-library-profiling"
131	kosmikus	1.1	fi
132	dcoutts	1.6	# Building GHCi libs on ppc64 causes "TOC overflow".
133			if use ppc64; then
134	dcoutts	1.5	cabalconf="${cabalconf} --disable-library-for-ghci"
135			fi
136	kosmikus	1.1
137	dcoutts	1.11	# Note: with Cabal-1.1.6.x we still do not have enough control
138			# to put the docs into the right place. They're currently going
139			# into /usr/share/${P}/ghc-x.y/doc/
140			# rather than /usr/share/doc/${PF}/
141			# Because we can only set the datadir, not the docdir.
142
143	kosmikus	1.1	./setup configure \
144			--ghc --prefix=/usr \
145			--with-compiler="$(ghc-getghc)" \
146			--with-hc-pkg="$(ghc-getghcpkg)" \
147	dcoutts	1.11	--prefix=/usr \
148			--libdir=/usr/$(get_libdir) \
149			--libsubdir=${P}/ghc-$(ghc-version) \
150			--datadir=/usr/share/ \
151			--datasubdir=${P}/ghc-$(ghc-version) \
152	kosmikus	1.1	${cabalconf} \
153	kosmikus	1.8	${CABAL_CONFIGURE_FLAGS} \
154	kosmikus	1.1	"$@" \|\| die "setup configure failed"
155			}
156
157			cabal-build() {
158			./setup build \
159			\|\| die "setup build failed"
160			}
161
162			cabal-copy() {
163			./setup copy \
164	dcoutts	1.11	--destdir="${D}" \
165	kosmikus	1.1	\|\| die "setup copy failed"
166
167			# cabal is a bit eager about creating dirs,
168			# so remove them if they are empty
169			rmdir "${D}/usr/bin" 2> /dev/null
170
171			# GHC 6.4 has a bug in get/setPermission and Cabal 1.1.1 has
172			# no workaround.
173			# set the +x permission on executables
174			if [[ -d "${D}/usr/bin" ]] ; then
175			chmod +x "${D}/usr/bin/"*
176			fi
177	dcoutts	1.11	# TODO: do we still need this?
178	kosmikus	1.1	}
179
180			cabal-pkg() {
181	kosmikus	1.9	# This does not actually register since we're using true instead
182	kosmikus	1.1	# of ghc-pkg. So it just leaves the .installed-pkg-config and we can
183			# register that ourselves (if it exists).
184	dcoutts	1.2	local result
185			local err
186
187	dcoutts	1.4	if [[ -n ${CABAL_HAS_LIBRARIES} ]]; then
188	kolmodin	1.12	sed -i "s\|$(ghc-getghcpkg)\|$(type -P true)\|" .setup-config
189	dcoutts	1.4	./setup register \|\| die "setup register failed"
190			if [[ -f .installed-pkg-config ]]; then
191			ghc-setup-pkg .installed-pkg-config
192			ghc-install-pkg
193			else
194			die "setup register has not generated a package configuration file"
195			fi
196	kosmikus	1.1	fi
197			}
198
199	kolmodin	1.13	# Some cabal libs are bundled along with some versions of ghc
200			# eg filepath-1.0 comes with ghc-6.6.1
201			# by putting CABAL_CORE_LIB_GHC_PV="6.6.1" in an ebuild we are declaring that
202			# when building with this version of ghc, the ebuild is a dummy that is it will
203			# install no files since the package is already included with ghc.
204			# However portage still records the dependency and we can upgrade the package
205			# to a later one that's not included with ghc.
206			# You can also put a space separated list, eg CABAL_CORE_LIB_GHC_PV="6.6 6.6.1".
207			cabal-is-dummy-lib() {
208			for version in ${CABAL_CORE_LIB_GHC_PV[*]}; do
209			[[ "$(ghc-version)" == "$version" ]] && return 0
210			done
211			return 1
212			}
213
214	kosmikus	1.1	# exported function: check if cabal is correctly installed for
215			# the currently active ghc (we cannot guarantee this with portage)
216			haskell-cabal_pkg_setup() {
217	dcoutts	1.11	ghc-package_pkg_setup
218			if [[ -z "${CABAL_BOOTSTRAP}" ]] && ! ghc-sanecabal "${CABAL_MIN_VERSION}"; then
219	kosmikus	1.1	eerror "The package dev-haskell/cabal is not correctly installed for"
220			eerror "the currently active version of ghc ($(ghc-version)). Please"
221			eerror "run ghc-updater or re-emerge dev-haskell/cabal."
222			die "cabal is not correctly installed"
223			fi
224	dcoutts	1.4	if [[ -z "${CABAL_HAS_BINARIES}" ]] && [[ -z "${CABAL_HAS_LIBRARIES}" ]]; then
225			eerror "QA: Neither bin nor lib are in CABAL_FEATURES."
226			fi
227	dcoutts	1.3	if [[ -n "${CABAL_UNKNOWN}" ]]; then
228			ewarn "Unknown entry in CABAL_FEATURES: ${CABAL_UNKNONW}"
229			fi
230	kolmodin	1.13	if cabal-is-dummy-lib; then
231			einfo "${P} is included in ghc-${CABAL_CORE_LIB_GHC_PV}, nothing to install."
232			fi
233	kosmikus	1.1	}
234
235			# exported function: cabal-style bootstrap configure and compile
236			cabal_src_compile() {
237	kolmodin	1.13	if ! cabal-is-dummy-lib; then
238			cabal-bootstrap
239			cabal-configure
240			cabal-build
241	kosmikus	1.1
242	kolmodin	1.13	if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
243			cabal-haddock
244			fi
245	kosmikus	1.1	fi
246			}
247			haskell-cabal_src_compile() {
248			cabal_src_compile
249			}
250
251			# exported function: cabal-style copy and register
252			cabal_src_install() {
253	kolmodin	1.13	if cabal-is-dummy-lib; then
254			# create a dummy local package conf file for the sake of ghc-updater
255			dodir "$(ghc-confdir)"
256			echo '[]' > "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
257			else
258			cabal-copy
259			cabal-pkg
260	kosmikus	1.1
261	kolmodin	1.13	if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
262			local cabalversion=$(ghc-extractportageversion dev-haskell/cabal)
263			if ! version_is_at_least "1.1.6" "${cabalversion}"; then
264			dohtml -r dist/doc/html/*
265			fi
266	dcoutts	1.11	fi
267	kosmikus	1.1	fi
268			}
269			haskell-cabal_src_install() {
270			cabal_src_install
271			}
272
273			EXPORT_FUNCTIONS pkg_setup src_compile src_install