Difference between revisions of "Haskell package guidelines (Italiano)"

From ArchWiki
Jump to: navigation, search
m (Automatic local building of Hackage Packages with cabal2arch using Bauerbill: Bauerbill has been officially discontinued)
m ([Haskell])
(27 intermediate revisions by 4 users not shown)
Line 1: Line 1:
[[Category:Guidelines (Italiano)]]
 
 
[[Category:Package development (Italiano)]]
 
[[Category:Package development (Italiano)]]
 +
[[en:Haskell Package Guidelines]]
 +
{{Package Guidelines (Italiano)}}
  
{{i18n|Haskell package guidelines}}
+
Haskell è ben supportato su Arch Linux, poichè GHC ed altri tools fondamentali sono disponibili nei [[Official Repositories (Italiano)|repository ufficiali]]; inoltre, un numero sempre maggiore di pacchetti vengono creati dal gruppo ArchHaskell, così come un'ampia parte del database di librerie di [http://hackage.haskell.org hackage.haskell.org] è [https://aur.archlinux.org/packages.php?O=0&L=0&C=0&K=arch-haskell&SeB=m&SB=n&SO=a&PP=100&do_Search=Go disponibile su AUR].
{{translateme}}
+
{{Nota|Questo articolo è in fase di traduzione. Seguite per ora le istruzioni della versione inglese.}}
+
  
'''Haskell on Arch Linux'''
+
Come avrete notato, la community che si occupa di Haskell su Arch Linux è attiva e ben organizzata, ma il vostro aiuto è sempre ben accetto.
  
Haskell is well supported on Arch Linux, with GHC and other key tools available via pacman, and 87% percent of [http://hackage.haskell.org hackage.haskell.org] library database [http://aur.archlinux.org/packages.php?O=0&L=0&C=0&K=arch-haskell&SeB=m&SB=n&SO=a&PP=100&do_Search=Go available via AUR].
+
==Community==
 +
È possibile consultare [[ArchHaskell]] per ulteriori informazioni sul gruppo.
  
'''[http://code.haskell.org/arch/arch-haskell-status.html The status of all Haskell packages in Arch Linux]'''
+
==Pacchetti Haskell==
 +
I tools fondamentali per Haskell, sono disponibili nel repository [extra]:
  
The community around Haskell on Arch is also active and well organized.
+
===[extra]===
 +
* [http://www.archlinux.org/packages/?arch=x86_64&repo=Extra&q=haskell&last_update=&limit=50 Elenco pacchetti Haskell contenuti in <nowiki>[extra]</nowiki>]
  
== Community ==
+
Il repository <nowiki>[extra]</nowiki> conterrà la piattaforma Haskell e le applicazioni più popolari.
  
The main resources for the Arch/Haskell community to interact and discuss are:
+
===<nowiki>[community]</nowiki>===
 +
* [http://www.archlinux.org/packages/?arch=x86_64&repo=Community&q=haskell&last_update=&limit=50 altri pacchetti Haskell]
  
* [http://www.gogloom.com/FreeNode/arch-haskell <nowiki>#arch-haskell</nowiki>] irc channel @ freenode.org
+
Il repository [community] fornisce pacchetti aggiuntivi che non fanno parte della piattaforma Haskell, come [[xmonad|xmonad]].
** Good for quick discussion and planning
+
* [http://haskell.org/mailman/listinfo/arch-haskell arch-haskell@haskell.org] mailing list
+
** Broader announcements, and automated updates
+
* [http://archhaskell.wordpress.com/ Arch Haskell Weekly News]
+
** A blog announcing our progress to the outside world.
+
  
== Haskell Packages ==
+
===[Haskell]===
 +
[haskell] è il repository ufficiale dell'ArchHaskell team. È l'ultimo luogo dove poter reperire pacchetti stabili, prima di utilizzare AUR o di compilare un pacchetto autonomamente con cabal2arch.
  
The core Haskell tools are available in the core system (extra):
+
È possibile utilizzare il suddetto repostitory aggiungendo la seguente linea al proprio {{ic|/etc/pacman.conf}}:
  
==== <nowiki>[Extra]</nowiki> ====
+
[haskell]
* [http://www.archlinux.org/packages/?arch=x86_64&repo=Extra&q=haskell&last_update=&limit=50 Haskell packages in the core system]
+
Server = http://xsounds.org/~haskell/$arch
  
Our [http://haskell.org/haskellwiki/Arch_Linux/Policy policy] is for [extra] to provide the Haskell platform, and popular Haskell applications.
+
I pacchetti contenuti nel repository [haskell], derivano dal tree dell'utente '''habs''', reperibile [https://github.com/archhaskell/habs qui]. È possibile usare un tool chiamato [https://github.com/magthe/cblrepo cblrepo] per sincronizzare il tree di '''habs''' con i pacchetti Haskell ufficiali provenienti da [http://hackage.haskell.org/packages/hackage.html Hackage].
  
==== <nowiki>AUR</nowiki> ====
+
Inserire [haskell] prima di [extra] farà si che i pacchetti provenienti dal repository [haskell] abbiano la precedenza in caso siano presenti anche in [extra].
  
* [http://aur.archlinux.org/packages.php?O=0&L=0&C=0&K=arch-haskell&SeB=m&SB=n&SO=a&PP=100&do_Search=Go Haskell packages in AUR]
+
===AUR===
 +
* [https://aur.archlinux.org/packages.php?O=0&L=0&C=0&K=arch-haskell&SeB=m&SB=n&SO=a&PP=100&do_Search=Go Pacchetti Haskell in AUR]
  
A huge number (almost 2000) packages built from http://hackage.haskell.org
+
AUR contiene un grande numero di pacchetti (quasi 2000) compilati da [http://hackage.haskell.org hackage.haskell.org]
  
These generally improve on installing directly from Hackage as they resolve required C libraries. They can be installed as, for example:
+
È preferibile installarli direttamente da AUR, invece che da Hackage, poichè vengono installate automaticamente tutte le librerie necessarie. Ad esempio:
  
    sudo paktahn -S haskell-csv
+
# paktahn -S haskell-csv
  
Anything not found here can be installed via [http://aur.archlinux.org/packages.php?ID=17411 cabal-install] direct from Hackage.
+
Tutto ciò che non è possibile trovare su AUR, può essere installato tramite {{pkg|cabal-install}}, che preleva il pacchetto direttamente da Hackage.
  
== Direction and strategy ==
+
Sfortunatamente, molti dei pacchetti su AUR non sono aggiornati a causa della mancanza di risorse. In sostanza, è possibile utilizzare cabal2arch per creare dei PKGBUILD direttamente da Hackage.
  
The strategy for Haskell on Arch Linux is to support the Haskell platform suite in [extra], and to track Hackage via AUR. This has been adopted as an [http://haskell.org/haskellwiki/Arch_Linux/Policy official policy document].
+
==Linee guida==
 +
Nella quasi totalità dei casi, è possibile convertire i pacchetti "cabalizzati" nel formato pacchetti usato da Arch, attraverso {{AUR|cabal2arch}}. È caldamente raccomandato usare sempre l'ultima versione disponibile di questo software, poichè rispetta le politiche di impacchettamento dei pacchetti Haskell. È possibile ottenere questo tool in diversi modi:
  
== Guidelines ==
+
* Aggiungendo il repository <nowiki>[haskell]</nowiki> a {{ic|/etc/pacman.conf}}, e usando [[Pacman (Italiano)|pacman]] per installare l'ultima versione
 +
* Scaricando e compilando i sorgenti del pacchetto {{AUR|cabal2arch}} da [[AUR (Italiano)|AUR]].
 +
* Installandolo direttamente da hackage usando "cabal install cabal2arch".
  
In almost all cases cabalised Haskell packages can be automatically translated into Arch packages, via the cabal2arch tool.
+
===cabal2arch: un esempio===
 +
Questo esempio spiega come creare un nuovo pacchetto usando cabal2arch. Nello specifico, si creerà un pacchetto per il formattatore di documenti Pandoc:
  
* [http://aur.archlinux.org/packages.php?ID=17471 Get the latest cabal2arch]
+
Innanzitutto, impostare il nome e l'indirizzo email da usare nel PKGBUILD che verrà generato:
  
It is strongly recommended that you use this tool, as it implements the packaging policy for Haskell packages.
+
export ARCH_HASKELL='My Name <my.name@domain.org>'
These packages are primarily managed by Don Stewart.  
+
  
Development version:
+
Poi, cercare la [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/pandoc pagina di Hackage relativa a Pandoc] ed identificare il link al file .cabal. Si passi il suddetto come argomento a cabal2arch:
  
* darcs get http://code.haskell.org/~dons/code/cabal2arch
+
{{bc|<nowiki>
 +
% cd /tmp
 +
% cabal2arch http://hackage.haskell.org/packages/archive/pandoc/1.6.0.1/pandoc.cabal
 +
Using /tmp/tmp.D7HAJJx2js/pandoc.cabal
 +
Feeding the PKGBUILD to `makepkg -g`...
 +
==> Retrieving Sources...
 +
  -> Downloading pandoc-1.6.0.1.tar.gz...
 +
--2011-05-14 07:25:39--  http://hackage.haskell.org/packages/archive/pandoc/1.6.0.1/pandoc-1.6.0.1.tar.gz
 +
Resolving hackage.haskell.org... 69.30.63.204
 +
Connecting to hackage.haskell.org|69.30.63.204|:80... connected.
 +
HTTP request sent, awaiting response... 200 OK
 +
Length: 355477 (347K) [application/x-tar]
 +
Saving to: “pandoc-1.6.0.1.tar.gz.part”
  
Or:
+
    0K .......... .......... .......... .......... .......... 14%  210K 1s
 +
    50K .......... .......... .......... .......... .......... 28%  393K 1s
 +
  100K .......... .......... .......... .......... .......... 43%  338K 1s
 +
  150K .......... .......... .......... .......... .......... 57%  419K 0s
 +
  200K .......... .......... .......... .......... .......... 72%  404K 0s
 +
  250K .......... .......... .......... .......... .......... 86%  554K 0s
 +
  300K .......... .......... .......... .......... .......  100%  506K=0.9s
  
* cabal install cabal2arch
+
2011-05-14 07:25:40 (369 KB/s) - “pandoc-1.6.0.1.tar.gz.part” saved [355477/355477]
  
Most things on http://hackage.haskell.org that are packageable, are already in AUR.
+
==> Generating checksums for source files...
 +
</nowiki>}}
  
If not, download and build cabal2arch, as below, and use that to create
+
Si controlli cosa è stato generato:
the package. This will ensure it follows standard naming, dependency and installation conventions. Drop by #arch-haskell to let us know what is going on.
+
  
===cabal2arch: an example===
+
haskell-pandoc
 +
% cd haskell-pandoc
 +
% ls
 +
haskell-pandoc.install PKGBUILD
  
This example illustrates how to create a new package with cabal2arch. We'll make a
+
È ora possibile esaminare il PKGBUILD e lo script .install relativo alla libreria:
new package for the delimited continuations library, CC-delcont:
+
  
First, find [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/CC-delcont the hackage page for CC-delcont], then identify the link to the .cabal file. Use this link
+
{{bc|<nowiki>
as an argument to cabal2arch:
+
# Maintainer:  
 
+
_hkgname=pandoc
$ cd /tmp
+
pkgname=haskell-pandoc
$ cabal2arch http://hackage.haskell.org/packages/archive/CC-delcont/0.2/CC-delcont.cabal
+
pkgver=1.6.0.1
Using /tmp/tmp.Ig0H8jCOyO/CC-delcont.cabal
+
pkgrel=1
Fetching http://hackage.haskell.org/packages/archive/CC-delcont/0.2/CC-delcont-0.2.tar.gz
+
pkgdesc="Conversion between markup formats"
Created /tmp/haskell-cc-delcont.tar.gz
+
url="http://hackage.haskell.org/package/${_hkgname}"
 
+
license=('GPL')
Checking what was created:
+
arch=('i686' 'x86_64')
 
+
makedepends=()
$ ls
+
depends=('ghc' 'haskell-http=4000.1.1' 'haskell-bytestring=0.9.1.10' 'haskell-containers=0.4.0.0' 'haskell-directory=1.1.0.0' 'haskell-extensible-exceptions=0.1.1.2' 'haskell-filepath=1.2.0.0' 'haskell-mtl=2.0.1.0' 'haskell-network=2.3.0.2' 'haskell-old-time=1.0.0.6' 'haskell-parsec=3.1.1' 'haskell-pretty=1.0.1.2' 'haskell-process=1.0.1.5' 'haskell-random=1.0.0.3' 'haskell-syb=0.3' 'haskell-texmath<0.5' 'haskell-utf8-string>=0.3' 'haskell-xhtml=3000.2.0.1' 'haskell-xml<1.4' 'haskell-zip-archive<0.2')
haskell-cc-delcont  haskell-cc-delcont.tar.gz
+
options=('strip')
 
+
source=(http://hackage.haskell.org/packages/archive/${_hkgname}/${pkgver}/${_hkgname}-${pkgver}.tar.gz)
The .tar.gz is a zipped PKGBUILD ready to upload to AUR.
+
install=${pkgname}.install
You can now inspect the PKGBUILD and install script for the library:
+
md5sums=('d19a630462595941b3100dff6f839aa3')
 
+
build() {
    # Contributor: Arch Haskell Team <arch-haskell@haskell.org>
+
     cd ${srcdir}/${_hkgname}-${pkgver}
    # Package generated by cabal2arch 0.6.1
+
     runhaskell Setup configure -O ${PKGBUILD_HASKELL_ENABLE_PROFILING:+-p } --enable-split-objs --enable-shared \
    pkgname=haskell-cc-delcont
+
      --prefix=/usr --docdir=/usr/share/doc/${pkgname} --libsubdir=\$compiler/site-local/\$pkgid
    pkgrel=1
+
     runhaskell Setup build
    pkgver=0.2
+
     runhaskell Setup haddock
    pkgdesc="Delimited continuations and dynamically scoped variables"
+
     runhaskell Setup register  --gen-script
    url="http://hackage.haskell.org/package/CC-delcont"
+
     runhaskell Setup unregister --gen-script
    license=('custom:OtherLicense')
+
    sed -i -r -e "s|ghc-pkg.*unregister[^ ]* |&'--force' |" unregister.sh
    arch=('i686' 'x86_64')
+
}
    makedepends=()
+
package() {
    depends=('ghc' 'haskell-cabal')
+
    cd ${srcdir}/${_hkgname}-${pkgver}
    options=('strip')
+
     install -D -m744 register.sh   ${pkgdir}/usr/share/haskell/${pkgname}/register.sh
    source=(http://hackage.haskell.org/packages/archive/CC-delcont/0.2/CC-delcont-0.2.tar.gz)
+
     install    -m744 unregister.sh ${pkgdir}/usr/share/haskell/${pkgname}/unregister.sh
    install=haskell-cc-delcont.install
+
     install -d -m755 ${pkgdir}/usr/share/doc/ghc/html/libraries
    md5sums=('e52149fca9bf76330a7c159917152790')
+
     ln -s /usr/share/doc/${pkgname}/html ${pkgdir}/usr/share/doc/ghc/html/libraries/${_hkgname}
    build() {
+
    runhaskell Setup copy --destdir=${pkgdir}
        cd ${srcdir}/CC-delcont-0.2
+
}
        runhaskell Setup configure --prefix=/usr --docdir=/usr/share/doc/${pkgname} || return 1
+
        runhaskell Setup build                  || return 1
+
        runhaskell Setup haddock || return 1
+
        runhaskell Setup register  --gen-script || return 1
+
        runhaskell Setup unregister --gen-script || return 1
+
        install -D -m744 register.sh  ${pkgdir}/usr/share/haskell/$pkgname/register.sh
+
        install    -m744 unregister.sh ${pkgdir}/usr/share/haskell/$pkgname/unregister.sh
+
        install -d -m755 $pkgdir/usr/share/doc/ghc/libraries
+
        ln -s /usr/share/doc/${pkgname}/html ${pkgdir}/usr/share/doc/ghc/libraries/CC-delcont
+
        runhaskell Setup copy --destdir=${pkgdir} || return 1
+
        install -D -m644 LICENSE ${pkgdir}/usr/share/licenses/$pkgname/LICENSE || return 1
+
        rm -f ${pkgdir}/usr/share/doc/${pkgname}/LICENSE
+
    }
+
 
+
It follows the conventions for Haskell packages:
+
 
+
* Maintainer is by default the Arch Haskell team.
+
* Libraries are prefixed with "haskell-"
+
* "core" and "extra" Haskell libraries are not included as explicit dependencies, since ghc provides them
+
* It uses cabal to generate a post-install register/unregister script, with a standard name.
+
* We use haddock to build the documentation.
+
* Profiling versions of the library aren't currently installed (''TODO'')
+
 
+
All Haskell libraries should follow these naming conventions, and using the cabal2arch tool
+
will ensure this is the case.
+
 
+
Inspect the bundle, and confirm you can build and install it:
+
 
+
    $ makepkg -s
+
    $ makepkg -i
+
 
+
And we're ready to go. Now your .tar.gz is ready to upload to AUR.
+
 
+
=== "Provides" ===
+
 
+
[http://haskell.org/haskellwiki/Arch_Linux/Preferred_Package_Tools See the discussion on the use of "provides" here].
+
 
+
===Uploading the the Haskell repository ===
+
 
+
'''This section is out of date'''
+
 
+
The following (ad hoc) script is currently used to upload packages after running cabal2arch to the respository, and keep it in sync:
+
+
#!/bin/sh
+
set -e
+
makepkg -i
+
scp *-x86_64.pkg.tar.gz code.haskell.org:/srv/code/arch/x86_64/
+
repo-add /home/dons/haskell.db.tar.gz *.pkg.tar.gz
+
rm -rf *.tar.gz pkg src
+
pwd=`pwd`
+
dir=`basename $pwd`
+
cd ..
+
scp -r $dir code.haskell.org:/srv/code/arch/x86_64/
+
scp $HOME/haskell.db.tar.gz code.haskell.org:/srv/code/arch/x86_64/
+
 
+
This is to be used by those with arch-haskell repository write permissions.
+
 
+
===Guidelines for Libraries===
+
 
+
In general, each .cabal file should map to one PKGBUILD. The following conventions hold:
+
 
+
* libraries have their cabal names prefixed with "haskell-"
+
* all haskell dependencies are statically linked, so can go in the makedepends field.
+
* all libraries have a dependency on 'ghc'
+
* libraries don't need to have explicit dependencies on core Haskell packages -- these come in the 'ghc' package. (e.g. array, base, containers, random,  process etc).
+
* be careful about dependencies from gtk2hs: cairo, svg, glib, gtk. These are all provided by the 'gtk2hs' package, not , e.g. "haskell-cairo"
+
* we want to resolve dependencies with a fixed constraint to base>=3.0
+
* be careful about dependencies on the libraries provided by the basic 'ghc' package, which include:
+
 
+
ALUT-2.1.0.0       cgi-3001.1.5.1      network-2.1.0.0       regex-base-0.72.0.1
+
Cabal-1.2.3.0      containers-0.1.0.1  old-locale-1.0.0.0    regex-compat-0.71.0.1
+
GLUT-2.1.1.1        directory-1.0.0.0    old-time-1.0.0.0      regex-posix-0.72.0.2
+
HUnit-1.2.0.0      fgl-5.4.1.1          packedstring-0.1.0.0  stm-2.1.1.0
+
OpenAL-1.3.1.1      filepath-1.1.0.0     parallel-1.0.0.0      template-haskell-2.2.0.0
+
OpenGL-2.2.1.1     haskell-src-1.0.1.1  parsec-2.1.0.0        time-1.1.2.0
+
QuickCheck-1.1.0.0  haskell98-1.0.1.0   pretty-1.0.0.0        unix-2.3.0.0
+
array-0.1.0.0      hpc-0.5.0.0          process-1.0.0.0      xhtml-3000.0.2.1
+
base-3.0.1.0        html-1.0.1.1        random-1.0.0.0
+
bytestring-0.9.0.1  mtl-1.1.0.0          readline-1.0.1.0
+
 
+
These libraries don't need explicit dependencies to be set. cabal2arch solves all  these constraints for us.
+
 
+
Registering Haskell libraries is done via a register hook:
+
 
+
build() {
+
     cd ${srcdir}/cabal2arch-0.1
+
     runhaskell Setup configure --prefix=/usr || return 1
+
     runhaskell Setup build                   || return 1
+
     -- generate register scripts
+
     runhaskell Setup register  --gen-script || return 1
+
     runhaskell Setup unregister --gen-script || return 1
+
     install -D -m744 register.sh   ${pkgdir}/usr/share/haskell/$pkgname/register.sh
+
     install    -m744 unregister.sh ${pkgdir}/usr/share/haskell/$pkgname/unregister.sh
+
     runhaskell Setup copy --destdir=${pkgdir} || return 1
+
     -- usual Haskell BSD3 license isnt' official
+
    install -D -m644 LICENSE ${pkgdir}/usr/share/licenses/$pkgname/LICENSE || return 1
+
}
+
 
+
* Examples:
+
haskell-zlib, haskell-mersenne-random
+
 
+
===Guidelines for Programs ===
+
 
+
* Have their normal name. Examples:
+
hmp3, xmonad, ghc, cabal-install
+
 
+
* Be careful about dynamically linked runtime dependencies on C. For example, all GHC-produced binaries
+
have a runtime dependency on 'gmp'. OpenGL or GtT-based binaries will have additional 'depends'. cabal2arch will attempt to work out the C dependencies, but there may be others implied by Haskell dependencies that are missed.
+
 
+
* Use executable stripping, --enable-executable-stripping. cabal2arch will do this automatically.
+
 
+
== Haskell on Arch: current state ==
+
 
+
* http://www.galois.com/~dons/arch-haskell-status.html
+
 
+
===AUR===
+
  
There's another [http://aur.archlinux.org/packages.php?O=0&L=0&C=0&K=haskell&SB=v&SO=d&PP=100&SeB=nd&do_Orphans= > 550 Haskell packages] in AUR.
+
</nowiki>}}
  
== Building all of Hackage ==
+
Si noti come vengono rispettate le convenzioni per i pacchetti Haskell:
 +
* Le librerie hanno il prefisso {{ic|haskell-}}
 +
* Tutte le librerie da cui il pacchetto dipende sono inserite in depends=() (quelle incluse nel pacchetto {{pkg|ghc}} sono, per ovvi motivi, omesse, essendo fornite da quest'ultimo)
 +
* Utilizza cabal per generare uno script di installazione per la registrazione/deregistrazione, con un nome standard
 +
* Si usa haddock per generare la documentazione.
  
The following simple script, with cabal-install and cabal2arch installed,
+
Tutte le librerie Haskel dovrebbero segure queste convenzioni, e l'uso dell'ultima versione di cabal2arch, assicura che vengano rispettate.
will do a simple run over all the Haskell packages on haskell.org,
+
creating arch packages for them. Before you start it is worthwhile removing all haskell packages, and reinstalling them. And then editing your unpacked haskell package directory to remove base libraries -- you probably don't want to install them.
+
  
 +
{{Nota|A partire da {{AUR|cabal2arch}} 1.1-2, viene generata nel PKGBUILD una nuova variabile d'ambiente: {{ic|PKGBUILD_HASKELL_ENABLE_PROFILING}}. Se questa ha un valore diverso da zero, come ad esempio {{ic|true}} o {{ic|1}}, verrà effettuata una build con il profiling abilitato. Per questo motivo, se un utente desidera attivarlo, si consiglia di esportare la suddetta variabile tramite {{ic|~/.bashrc}} o {{ic|~/.zshrc}}.}}
  
    #!/bin/sh
+
===Linee guida per librerie===
    cabal update
+
Solitamente, ad ogni file .cabal dovrebbe corrispondere un PKGBUILD. Rimangono le seguenti convenzioni:
    tmpdir=`mktemp -d`
+
    finaldir=`mktemp -d`
+
    cd $tmpdir
+
    tar xzf $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz
+
    for dir in * ; do
+
        if [ ! -d $dir ] ; then
+
            continue
+
        fi
+
        cd $dir
+
        lib=`ls --color=never -1 | tail -1`
+
        echo "************** Building package for $dir-$lib"
+
        cd $lib
+
        cabal2arch *.cabal > $dir.log 2>&1
+
        cd `find . -type d -a ! -name '.'`
+
        if makepkg -sm > ../$dir.log 2>&1 ; then
+
            echo "OK: " $dir-$lib
+
            cp *.pkg.tar.gz $finaldir/
+
            sudo pacman -A *.pkg.tar.gz
+
            rm *.pkg.tar.gz
+
            rm -rf pkg src *.tar.gz
+
            cd ..
+
            cp -R `find . -type d -a ! -name '.'` $finaldir/
+
            cp *.tar.gz $finaldir/
+
        else
+
            echo "Failed"
+
        fi
+
        cd $tmpdir
+
    done
+
    echo `ls $finaldir/*pkg* | wc -l` "build packages in $finaldir"
+
    echo "Now: scp -r $finaldir/* code.haskell.org:/srv/code/arch/$MACHTYPE/"
+
  
== Automatic local building of Hackage Packages with cabal2arch using Bauerbill ==
+
* Le librerie devono avere il prefisso {{ic|haskell-}}
{{Warning|''Bauerbill'' development has been officially discontinued: its latest version does not work with            ''pacman>&#61;3.5''. See [[https://bbs.archlinux.org/viewtopic.php?id&#61;115660]].}}
+
* Tutte le librerie devono dipendere da {{pkg|ghc}}
Although there are a number of haskell packages on AUR, there will always be outdated packages on AUR. If this happens and you want to create a fully updated package you would normally use cabal2arch. This however can become painful/time consuming if you have numerous packages with different dependencies (some of which may/may not be updated). Instead you can automatic this process by using [[Bauerbill]] which has the --hackage flag, allowing you to create AUR packages from Hackage locally. Below is an example of some common commands
+
* Tutte le dipendenze devono essere incluse nell'array {{ic|depends}} del PKGBUILD
 +
* Si faccia attenzione alle librerie che dipendono da gtk2hs: cairo, svg, glib, gtk sono fornite dal pacchetto {{pkg|gtk2hs}}, non ad esempio da "haskell-cairo"
  
    bauerbill -S --hackage [pkgs] : build [pkgs] directly from Hackage*
+
La registrazione delle librerie Haskell viene effettuata tramite l'hook register. A tal proposito, si veda sopra.
    bauerbill -Si --hackage [pkgs] : look up information about [pkgs]
+
    bauerbill -Ss --hackage [args] : search for [args]
+
    bauerbill -Qu --hackage : list upgradable Hackage packages
+
  
Syncing packages with the --hackage flag will interactively download all dependencies of the package from Hackage, convert them using cabal2arch and then build/install them (while checking dependencies). You can combine this with the --aur flag to give precedence to Hackage packages that are on AUR
+
===Linee guida per i programmi===
 +
* Mantengono il nome originale
 +
* Si faccia attenzione alle librerie C richieste come dipendenze a runtime. Ad esempio, tutti i binari prodotti con GHC, dipenderanno da 'gmp, così come quelli che usano OpenGL o sono basati sulla versione -git del pacchetto da compilare, avranno dipendenze addizionali. cabal2arch cercherà di risolvere questi problemi autonomamente, ma potrebbero esserci dipendenze addizionali che non vengono risolte, nel qual caso spetterà all'utente far fronte a questa evenienza.
 +
* Utilizzare lo stripping degli eseguibili ({{ic |--enable-executable-stripping}}). cabal2arch effettua questa operazione automaticamente.

Revision as of 07:55, 17 June 2012

Haskell è ben supportato su Arch Linux, poichè GHC ed altri tools fondamentali sono disponibili nei repository ufficiali; inoltre, un numero sempre maggiore di pacchetti vengono creati dal gruppo ArchHaskell, così come un'ampia parte del database di librerie di hackage.haskell.org è disponibile su AUR.

Come avrete notato, la community che si occupa di Haskell su Arch Linux è attiva e ben organizzata, ma il vostro aiuto è sempre ben accetto.

Community

È possibile consultare ArchHaskell per ulteriori informazioni sul gruppo.

Pacchetti Haskell

I tools fondamentali per Haskell, sono disponibili nel repository [extra]:

[extra]

Il repository [extra] conterrà la piattaforma Haskell e le applicazioni più popolari.

[community]

Il repository [community] fornisce pacchetti aggiuntivi che non fanno parte della piattaforma Haskell, come xmonad.

[Haskell]

[haskell] è il repository ufficiale dell'ArchHaskell team. È l'ultimo luogo dove poter reperire pacchetti stabili, prima di utilizzare AUR o di compilare un pacchetto autonomamente con cabal2arch.

È possibile utilizzare il suddetto repostitory aggiungendo la seguente linea al proprio /etc/pacman.conf:

[haskell]
Server = http://xsounds.org/~haskell/$arch

I pacchetti contenuti nel repository [haskell], derivano dal tree dell'utente habs, reperibile qui. È possibile usare un tool chiamato cblrepo per sincronizzare il tree di habs con i pacchetti Haskell ufficiali provenienti da Hackage.

Inserire [haskell] prima di [extra] farà si che i pacchetti provenienti dal repository [haskell] abbiano la precedenza in caso siano presenti anche in [extra].

AUR

AUR contiene un grande numero di pacchetti (quasi 2000) compilati da hackage.haskell.org

È preferibile installarli direttamente da AUR, invece che da Hackage, poichè vengono installate automaticamente tutte le librerie necessarie. Ad esempio:

# paktahn -S haskell-csv

Tutto ciò che non è possibile trovare su AUR, può essere installato tramite cabal-install, che preleva il pacchetto direttamente da Hackage.

Sfortunatamente, molti dei pacchetti su AUR non sono aggiornati a causa della mancanza di risorse. In sostanza, è possibile utilizzare cabal2arch per creare dei PKGBUILD direttamente da Hackage.

Linee guida

Nella quasi totalità dei casi, è possibile convertire i pacchetti "cabalizzati" nel formato pacchetti usato da Arch, attraverso cabal2archAUR. È caldamente raccomandato usare sempre l'ultima versione disponibile di questo software, poichè rispetta le politiche di impacchettamento dei pacchetti Haskell. È possibile ottenere questo tool in diversi modi:

  • Aggiungendo il repository [haskell] a /etc/pacman.conf, e usando pacman per installare l'ultima versione
  • Scaricando e compilando i sorgenti del pacchetto cabal2archAUR da AUR.
  • Installandolo direttamente da hackage usando "cabal install cabal2arch".

cabal2arch: un esempio

Questo esempio spiega come creare un nuovo pacchetto usando cabal2arch. Nello specifico, si creerà un pacchetto per il formattatore di documenti Pandoc:

Innanzitutto, impostare il nome e l'indirizzo email da usare nel PKGBUILD che verrà generato:

export ARCH_HASKELL='My Name <my.name@domain.org>'

Poi, cercare la pagina di Hackage relativa a Pandoc ed identificare il link al file .cabal. Si passi il suddetto come argomento a cabal2arch:

% cd /tmp
% cabal2arch http://hackage.haskell.org/packages/archive/pandoc/1.6.0.1/pandoc.cabal
Using /tmp/tmp.D7HAJJx2js/pandoc.cabal
Feeding the PKGBUILD to `makepkg -g`...
==> Retrieving Sources...
  -> Downloading pandoc-1.6.0.1.tar.gz...
--2011-05-14 07:25:39--  http://hackage.haskell.org/packages/archive/pandoc/1.6.0.1/pandoc-1.6.0.1.tar.gz
Resolving hackage.haskell.org... 69.30.63.204
Connecting to hackage.haskell.org|69.30.63.204|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 355477 (347K) [application/x-tar]
Saving to: “pandoc-1.6.0.1.tar.gz.part”

     0K .......... .......... .......... .......... .......... 14%  210K 1s
    50K .......... .......... .......... .......... .......... 28%  393K 1s
   100K .......... .......... .......... .......... .......... 43%  338K 1s
   150K .......... .......... .......... .......... .......... 57%  419K 0s
   200K .......... .......... .......... .......... .......... 72%  404K 0s
   250K .......... .......... .......... .......... .......... 86%  554K 0s
   300K .......... .......... .......... .......... .......   100%  506K=0.9s

2011-05-14 07:25:40 (369 KB/s) - “pandoc-1.6.0.1.tar.gz.part” saved [355477/355477]

==> Generating checksums for source files...

Si controlli cosa è stato generato:

haskell-pandoc
% cd haskell-pandoc
% ls
haskell-pandoc.install PKGBUILD

È ora possibile esaminare il PKGBUILD e lo script .install relativo alla libreria:

# Maintainer: 
_hkgname=pandoc
pkgname=haskell-pandoc
pkgver=1.6.0.1
pkgrel=1
pkgdesc="Conversion between markup formats"
url="http://hackage.haskell.org/package/${_hkgname}"
license=('GPL')
arch=('i686' 'x86_64')
makedepends=()
depends=('ghc' 'haskell-http=4000.1.1' 'haskell-bytestring=0.9.1.10' 'haskell-containers=0.4.0.0' 'haskell-directory=1.1.0.0' 'haskell-extensible-exceptions=0.1.1.2' 'haskell-filepath=1.2.0.0' 'haskell-mtl=2.0.1.0' 'haskell-network=2.3.0.2' 'haskell-old-time=1.0.0.6' 'haskell-parsec=3.1.1' 'haskell-pretty=1.0.1.2' 'haskell-process=1.0.1.5' 'haskell-random=1.0.0.3' 'haskell-syb=0.3' 'haskell-texmath<0.5' 'haskell-utf8-string>=0.3' 'haskell-xhtml=3000.2.0.1' 'haskell-xml<1.4' 'haskell-zip-archive<0.2')
options=('strip')
source=(http://hackage.haskell.org/packages/archive/${_hkgname}/${pkgver}/${_hkgname}-${pkgver}.tar.gz)
install=${pkgname}.install
md5sums=('d19a630462595941b3100dff6f839aa3')
build() {
    cd ${srcdir}/${_hkgname}-${pkgver}
    runhaskell Setup configure -O ${PKGBUILD_HASKELL_ENABLE_PROFILING:+-p } --enable-split-objs --enable-shared \
       --prefix=/usr --docdir=/usr/share/doc/${pkgname} --libsubdir=\$compiler/site-local/\$pkgid
    runhaskell Setup build
    runhaskell Setup haddock
    runhaskell Setup register   --gen-script
    runhaskell Setup unregister --gen-script
    sed -i -r -e "s|ghc-pkg.*unregister[^ ]* |&'--force' |" unregister.sh
}
package() {
    cd ${srcdir}/${_hkgname}-${pkgver}
    install -D -m744 register.sh   ${pkgdir}/usr/share/haskell/${pkgname}/register.sh
    install    -m744 unregister.sh ${pkgdir}/usr/share/haskell/${pkgname}/unregister.sh
    install -d -m755 ${pkgdir}/usr/share/doc/ghc/html/libraries
    ln -s /usr/share/doc/${pkgname}/html ${pkgdir}/usr/share/doc/ghc/html/libraries/${_hkgname}
    runhaskell Setup copy --destdir=${pkgdir}
}

Si noti come vengono rispettate le convenzioni per i pacchetti Haskell:

  • Le librerie hanno il prefisso haskell-
  • Tutte le librerie da cui il pacchetto dipende sono inserite in depends=() (quelle incluse nel pacchetto ghc sono, per ovvi motivi, omesse, essendo fornite da quest'ultimo)
  • Utilizza cabal per generare uno script di installazione per la registrazione/deregistrazione, con un nome standard
  • Si usa haddock per generare la documentazione.

Tutte le librerie Haskel dovrebbero segure queste convenzioni, e l'uso dell'ultima versione di cabal2arch, assicura che vengano rispettate.

Nota: A partire da cabal2archAUR 1.1-2, viene generata nel PKGBUILD una nuova variabile d'ambiente: PKGBUILD_HASKELL_ENABLE_PROFILING. Se questa ha un valore diverso da zero, come ad esempio true o 1, verrà effettuata una build con il profiling abilitato. Per questo motivo, se un utente desidera attivarlo, si consiglia di esportare la suddetta variabile tramite ~/.bashrc o ~/.zshrc.

Linee guida per librerie

Solitamente, ad ogni file .cabal dovrebbe corrispondere un PKGBUILD. Rimangono le seguenti convenzioni:

  • Le librerie devono avere il prefisso haskell-
  • Tutte le librerie devono dipendere da ghc
  • Tutte le dipendenze devono essere incluse nell'array depends del PKGBUILD
  • Si faccia attenzione alle librerie che dipendono da gtk2hs: cairo, svg, glib, gtk sono fornite dal pacchetto gtk2hs, non ad esempio da "haskell-cairo"

La registrazione delle librerie Haskell viene effettuata tramite l'hook register. A tal proposito, si veda sopra.

Linee guida per i programmi

  • Mantengono il nome originale
  • Si faccia attenzione alle librerie C richieste come dipendenze a runtime. Ad esempio, tutti i binari prodotti con GHC, dipenderanno da 'gmp, così come quelli che usano OpenGL o sono basati sulla versione -git del pacchetto da compilare, avranno dipendenze addizionali. cabal2arch cercherà di risolvere questi problemi autonomamente, ma potrebbero esserci dipendenze addizionali che non vengono risolte, nel qual caso spetterà all'utente far fronte a questa evenienza.
  • Utilizzare lo stripping degli eseguibili (--enable-executable-stripping). cabal2arch effettua questa operazione automaticamente.