Difference between revisions of "Go package guidelines"

From ArchWiki
Jump to: navigation, search
m (Using go get (recommended))
(Added note about go-makepkg tool)
 
(17 intermediate revisions by 8 users not shown)
Line 1: Line 1:
 
[[Category:Package development]]
 
[[Category:Package development]]
{{Package Guidelines}}
+
{{Package guidelines}}
  
 
[[Wikipedia:Go (programming language)|Go]] is well supported on Arch Linux.
 
[[Wikipedia:Go (programming language)|Go]] is well supported on Arch Linux.
  
The {{Pkg|go}} package contains the '''go''' tool (for running {{Ic|go fix}}, {{Ic|go build}} etc). There is also the {{AUR|go-hg}} package in [[AUR]] and {{Pkg|gcc-go}} which provides {{Ic|gccgo}}.
+
The {{Pkg|go}} package contains the '''go''' tool (for running {{Ic|go fix}}, {{Ic|go build}} etc). There is also {{Pkg|gcc-go}} which provides {{Ic|gccgo}}.
 +
 
 +
[https://github.com/seletskiy/go-makepkg go-makepkg] tool provides easy way of packaging Go programs without need of crafting PKGBUILD files manually.
  
 
= General guidelines =
 
= General guidelines =
Line 12: Line 14:
 
** Be creative if the name is already taken.
 
** Be creative if the name is already taken.
 
* For libraries written in Go, use {{Ic|go-''modulename''}}, in lowercase.
 
* For libraries written in Go, use {{Ic|go-''modulename''}}, in lowercase.
* If the name already starts with {{Ic|go-}}, don't call the package {{Ic|go-''go-modulename''}}, but just {{Ic|go-''modulename''}}.
+
** If the name already starts with {{Ic|go-}}, do not call the package {{Ic|go-''go-modulename''}}, but just {{Ic|go-''modulename''}}.
* For PKGBUILDS that uses the "go" tool to download the package, only add "-git" to the package name if it's not built from a tarball or a from a tagged release (but from trunk/HEAD).
+
* For PKGBUILDS that uses the "go" tool to download the package, only add "-git" to the package name if it is not built from a tarball or a from a tagged release (but from trunk/HEAD).
** Similarly for mercurial packages, only add "-hg" to the package name if it's not a release-revision.
+
** Similarly for mercurial packages, only add "-hg" to the package name if it is not a release-revision.
 
** Extend this pattern for other version control systems.
 
** Extend this pattern for other version control systems.
 
** The go tool has its own logic for which branch or tag it should use. See {{Ic|go get --help}}.
 
** The go tool has its own logic for which branch or tag it should use. See {{Ic|go get --help}}.
 
* Consider adding the name of the author to the package name if there are several applications that are named the same, like {{AUR|dcpu16-kballard}}.
 
* Consider adding the name of the author to the package name if there are several applications that are named the same, like {{AUR|dcpu16-kballard}}.
 
** In general, the most popular packages should be allowed to use the shortest or "best" name.
 
** In general, the most popular packages should be allowed to use the shortest or "best" name.
* Postfixes to the package names (like {{Ic|-hg}}, {{Ic|-git}} or {{Ic|-svn}}) are optional if there are no official releases from the project in question. On one hand, it's common to use them when the package downloads from a VCS. On the other hand, most Go projects don't have any release-tarballs, only the repo which is used for branching/tagging the official release, if it's not ''trunk''. Also, {{Ic|go get}}, which is the "official" way to install Go modules, uses the repositories directly. Use your better judgement.
+
* Postfixes to the package names (like {{Ic|-hg}}, {{Ic|-git}} or {{Ic|-svn}}) are optional if there are no official releases from the project in question. On one hand, it is common to use them when the package downloads from a VCS. On the other hand, most Go projects do not have any release-tarballs, only the repo which is used for branching/tagging the official release, if it is not ''trunk''. Also, {{Ic|go get}}, which is the "official" way to install Go modules, uses the repositories directly. Use your better judgement.
  
 
== Packaging ==
 
== Packaging ==
Line 25: Line 27:
 
* Some Go applications or libraries have not been updated to the latest version of Go yet.
 
* Some Go applications or libraries have not been updated to the latest version of Go yet.
 
** Running {{Ic|go build -fix}} may often work, but it may have to be fixed by the developer. Report an issue upstream if this is the case.
 
** Running {{Ic|go build -fix}} may often work, but it may have to be fixed by the developer. Report an issue upstream if this is the case.
* Several Go projects doesn't have a version number or a license file.
+
* Several Go projects do not have a version number or a license file.
 
** Use license=('unknown') and report an issue to the developer if a license file is missing.
 
** Use license=('unknown') and report an issue to the developer if a license file is missing.
** Use version "0.1", "1" or the git-revision (or equivivalent for other version control systems) if the version number is missing.
+
** Use version "0.1", "1" or the git-revision (or equivalent for other version control systems) if the version number is missing.
 
** Alternatively, use the current date as the version number, in this form {{Ic|YYYYMMDD}}.
 
** Alternatively, use the current date as the version number, in this form {{Ic|YYYYMMDD}}.
* Since Go applications are usually statically compiled, it's hard to envision reasons for packaging Go libraries instead of just Go applications.
+
* Since Go applications are usually statically compiled, it is hard to envision reasons for packaging Go libraries instead of just Go applications.
  
 
= Sample PKGBUILDs =
 
= Sample PKGBUILDs =
Line 50: Line 52:
  
 
build() {
 
build() {
   cd "$srcdir/$pkgname-$pkgver"
+
   cd "$pkgname-$pkgver"
  
 
   go build
 
   go build
Line 56: Line 58:
  
 
package() {
 
package() {
   cd "$srcdir/$pkgname-$pkgver"
+
   cd "$pkgname-$pkgver"
  
 
   install -Dm755 "$pkgname-$pkgver" "$pkgdir/usr/bin/$pkgname"
 
   install -Dm755 "$pkgname-$pkgver" "$pkgdir/usr/bin/$pkgname"
Line 85: Line 87:
  
 
build() {
 
build() {
  cd "$srcdir"
 
 
 
   go build -o "$pkgname"
 
   go build -o "$pkgname"
 
}
 
}
  
 
package() {
 
package() {
  cd "$srcdir"
 
 
 
   install -Dm755 "$pkgname" "$pkgdir/usr/bin/$pkgname"
 
   install -Dm755 "$pkgname" "$pkgdir/usr/bin/$pkgname"
 
}
 
}
Line 100: Line 98:
 
=== Sample packages ===
 
=== Sample packages ===
 
* {{AUR|gorun}}
 
* {{AUR|gorun}}
 
== Sample PKGBUILDs for Go libraries (uncommon) ==
 
 
{{Warning| There's not really any point in packaging libraries until Go supports dynamic libraries! }}
 
 
{{Note| Not all libraries are upgraded to work with Go1 yet! If in doubt, try installing with {{Ic|go get}} first, before packaging.}}
 
 
=== Using ''go get'' ===
 
 
This is the recommended way, instead of the method below.
 
 
Here's a way that relies on {{Ic|go get}}.
 
 
You probably won't need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
 
 
If this doesn't work, test with {{Ic|go get}} first. Change ''mercurial'' to ''git'', if that's what your package uses.
 
 
{{Note| Remove {{Ic|/...}} if the PKGBUILD fails!}}
 
 
{{bc|<nowiki># Maintainer: NAME <EMAIL>
 
 
pkgname=go-net
 
pkgver=20120515
 
pkgrel=1
 
pkgdesc="Extra network libraries for Go (dict, spdy, websocket)"
 
arch=('x86_64' 'i686')
 
url="http://code.google.com/p/go"
 
license=('BSD')
 
depends=('go')
 
makedepends=('mercurial')
 
options=('!strip' '!emptydirs')
 
_gourl=code.google.com/p/go.net
 
 
build() {
 
  cd "$srcdir"
 
  GOPATH="$srcdir" go get -fix -v -x ${_gourl}/...
 
}
 
 
check() {
 
  source /etc/profile.d/go.sh
 
  GOPATH="$GOPATH:$srcdir" go test -v -x ${_gourl}/...
 
}
 
 
package() {
 
  source /etc/profile.d/go.sh
 
  mkdir -p "$pkgdir/$GOPATH"
 
  cp -Rv --preserve=timestamps ${srcdir}/{src,pkg} "$pkgdir/$GOPATH"
 
 
  # Package license (if available)
 
  for f in LICENSE COPYING LICENSE.* COPYING.*; do
 
    if [ -e "$srcdir/src/$_gourl/$f" ]; then
 
      install -Dm644 "$srcdir/src/$_gourl/$f" \
 
        "$pkgdir/usr/share/licenses/$pkgname/$f"
 
    fi
 
  done
 
}
 
 
# vim:set ts=2 sw=2 et:</nowiki>}}
 
 
Thanks to Rémy Oudompheng‎ for this one.
 
 
Add "|| return 0" after the {{Ic|go test}} line if you wish to force the test to succeed. It's recommended to report the issue upstream to the relevant developers instead.
 
 
==== Sample packages ====
 
* {{AUR|go-web}}
 
 
==== Troubleshooting ====
 
* If you get the error that there are two packages found, both package {{Ic|main}} and another package, try removing the corresponding .go file for the {{Ic|main}} package in the {{Ic|build()}} function. Alternatively, move it elsewhere when building and then copy it to {{Ic|/usr/share/doc/$pkgname/examples}} in the {{Ic|package()}} function.
 
 
=== Using ''go get''===
 
 
Here's another way that relies on {{Ic|go get}}. It can be nice to have if the {{Ic|go get}} method above doesn't work.
 
 
You probably won't need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
 
 
If this doesn't work, test with {{Ic|go get}} first.
 
 
{{bc|<nowiki># Maintainer: NAME <EMAIL>
 
 
pkgname=go-PACKAGENAME
 
pkgver=1.2.3
 
pkgrel=1
 
pkgdesc="PACKAGE DESCRIPTION"
 
arch=('x86_64' 'i686')
 
url="http://SERVER/$pkgname/"
 
license=('MIT')
 
makedepends=('go' 'git')
 
options=('!strip' '!emptydirs')
 
_gourl=SERVER.NET/PATH/MODULENAME
 
 
build() {
 
  cd "$srcdir"
 
  export GOROOT=/usr/lib/go
 
 
  rm -rf build
 
  mkdir -p build/go
 
  cd build/go
 
 
  for f in "$GOROOT/"*; do
 
    ln -s "$f"
 
  done
 
 
  rm pkg
 
  mkdir pkg
 
  cd pkg
 
 
  for f in "$GOROOT/pkg/"*; do
 
    ln -s "$f"
 
  done
 
 
  platform=`for f in "$GOROOT/pkg/"*; do echo \`basename $f\`; done|grep linux`
 
 
  rm "$platform"
 
  mkdir "$platform"
 
  cd "$platform"
 
 
  for f in "$GOROOT/pkg/$platform/"*.h; do
 
    ln -s "$f"
 
  done
 
 
  export GOROOT="$srcdir/build/go"
 
  export GOPATH="$srcdir/build"
 
 
  go get -fix "$_gourl"
 
}
 
 
package() {
 
  cd "$srcdir"
 
 
  source /etc/profile.d/go.sh
 
  export GOROOT="$GOPATH"
 
 
  # Package go package files
 
  for f in "$srcdir/build/go/pkg/"* "$srcdir/build/pkg/"*; do
 
    # If it's a directory
 
    if [ -d "$f" ]; then
 
      cd "$f"
 
      mkdir -p "$pkgdir/$GOROOT/pkg/`basename $f`"
 
      for z in *; do
 
        # Check if the directory name matches
 
        if [ "$z" == `echo $_gourl | cut -d/ -f1` ]; then
 
          cp -r $z "$pkgdir/$GOROOT/pkg/`basename $f`"
 
        fi
 
      done
 
      cd ..
 
    fi
 
  done
 
 
  # Package source files
 
  if [ -d "$srcdir/build/src" ]; then
 
    mkdir -p "$pkgdir/$GOROOT/src/pkg"
 
    cp -r "$srcdir/build/src/"* "$pkgdir/$GOROOT/src/pkg/"
 
    find "$pkgdir" -depth -type d -name .git -exec rm -r {} \;
 
  fi
 
 
  # Package license (if available)
 
  for f in LICENSE COPYING LICENSE.* COPYING.*; do
 
    if [ -e "$srcdir/build/src/$_gourl/$f" ]; then
 
      install -Dm644 "$srcdir/build/src/$_gourl/$f" \
 
        "$pkgdir/usr/share/licenses/$pkgname/$f"
 
    fi
 
  done
 
}
 
 
# vim:set ts=2 sw=2 et:</nowiki>}}
 
  
 
== Sample PKGBUILDs for Go libraries that also includes executables ==
 
== Sample PKGBUILDs for Go libraries that also includes executables ==
Line 272: Line 105:
 
This is the recommended way, instead of the method below.
 
This is the recommended way, instead of the method below.
  
Here's a way that relies on go get.
+
Here is a way that relies on go get.
  
You probably won't need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
+
You probably will not need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
  
If this doesn't work, test with go get first.
+
If this does not work, test with go get first.
  
 
{{Note| Remove {{Ic|/...}} if the PKGBUILD fails!}}
 
{{Note| Remove {{Ic|/...}} if the PKGBUILD fails!}}
Line 287: Line 120:
 
pkgdesc="Code indexing and search written in Go"
 
pkgdesc="Code indexing and search written in Go"
 
arch=('x86_64' 'i686')
 
arch=('x86_64' 'i686')
url="http://code.google.com/p/codesearch"
+
url="https://github.com/google/codesearch"
 
license=('BSD')
 
license=('BSD')
 
depends=('go')
 
depends=('go')
 
makedepends=('mercurial')
 
makedepends=('mercurial')
 
options=('!strip' '!emptydirs')
 
options=('!strip' '!emptydirs')
_gourl=code.google.com/p/codesearch
+
_gourl=github.com/google/codesearch
  
 
build() {
 
build() {
  cd "$srcdir"
 
 
   GOPATH="$srcdir" go get -fix -v -x ${_gourl}/...
 
   GOPATH="$srcdir" go get -fix -v -x ${_gourl}/...
 
}
 
}
  
 
check() {
 
check() {
  source /etc/profile.d/go.sh
 
 
   GOPATH="$GOPATH:$srcdir" go test -v -x ${_gourl}/...
 
   GOPATH="$GOPATH:$srcdir" go test -v -x ${_gourl}/...
 
}
 
}
  
 
package() {
 
package() {
  source /etc/profile.d/go.sh
+
   mkdir -p "$pkgdir/usr/bin"
   mkdir -p "${pkgdir}/usr/bin"
+
   install -p -m755 "$srcdir/bin/"* "$pkgdir/usr/bin"
   install -p -m755 ${srcdir}/bin/* "$pkgdir/usr/bin"
+
  
 
   mkdir -p "$pkgdir/$GOPATH"
 
   mkdir -p "$pkgdir/$GOPATH"
   cp -Rv --preserve=timestamps ${srcdir}/{src,pkg} "$pkgdir/$GOPATH"
+
   cp -Rv --preserve=timestamps "$srcdir/"{src,pkg} "$pkgdir/$GOPATH"
  
 
   # Package license (if available)
 
   # Package license (if available)
Line 327: Line 157:
 
=== Using ''go get'' ===
 
=== Using ''go get'' ===
  
Here's another way that relies on {{Ic|go get}}.
+
Here is another way that relies on {{Ic|go get}}.
  
You probably won't need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
+
You probably will not need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).
  
If this doesn't work, test with {{Ic|go get}} first.
+
If this does not work, test with {{Ic|go get}} first.
  
 
{{bc|<nowiki># Maintainer: NAME <EMAIL>
 
{{bc|<nowiki># Maintainer: NAME <EMAIL>
Line 347: Line 177:
  
 
build() {
 
build() {
  cd "$srcdir"
 
 
 
   export GOROOT=/usr/lib/go
 
   export GOROOT=/usr/lib/go
  
Line 394: Line 222:
  
 
package() {
 
package() {
  cd "$srcdir"
 
 
  source /etc/profile.d/go.sh
 
 
   export GOROOT="$GOPATH"
 
   export GOROOT="$GOPATH"
  

Latest revision as of 04:59, 30 October 2015

Package creation guidelines

CLRCrossEclipseFree PascalGNOMEGoHaskellJavaKDEKernelLispMinGWNonfreeOCamlPerlPHPPythonRubyVCSWebWine

Go is well supported on Arch Linux.

The go package contains the go tool (for running go fix, go build etc). There is also gcc-go which provides gccgo.

go-makepkg tool provides easy way of packaging Go programs without need of crafting PKGBUILD files manually.

General guidelines

Naming

  • For applications written in Go, use the name of the application as the package name, in lowercase.
    • Be creative if the name is already taken.
  • For libraries written in Go, use go-modulename, in lowercase.
    • If the name already starts with go-, do not call the package go-go-modulename, but just go-modulename.
  • For PKGBUILDS that uses the "go" tool to download the package, only add "-git" to the package name if it is not built from a tarball or a from a tagged release (but from trunk/HEAD).
    • Similarly for mercurial packages, only add "-hg" to the package name if it is not a release-revision.
    • Extend this pattern for other version control systems.
    • The go tool has its own logic for which branch or tag it should use. See go get --help.
  • Consider adding the name of the author to the package name if there are several applications that are named the same, like dcpu16-kballardAUR.
    • In general, the most popular packages should be allowed to use the shortest or "best" name.
  • Postfixes to the package names (like -hg, -git or -svn) are optional if there are no official releases from the project in question. On one hand, it is common to use them when the package downloads from a VCS. On the other hand, most Go projects do not have any release-tarballs, only the repo which is used for branching/tagging the official release, if it is not trunk. Also, go get, which is the "official" way to install Go modules, uses the repositories directly. Use your better judgement.

Packaging

  • Go projects are either just library files, just executables or both. Choose the appropriate way of packaging them. There are several examples below.
  • Some Go applications or libraries have not been updated to the latest version of Go yet.
    • Running go build -fix may often work, but it may have to be fixed by the developer. Report an issue upstream if this is the case.
  • Several Go projects do not have a version number or a license file.
    • Use license=('unknown') and report an issue to the developer if a license file is missing.
    • Use version "0.1", "1" or the git-revision (or equivalent for other version control systems) if the version number is missing.
    • Alternatively, use the current date as the version number, in this form YYYYMMDD.
  • Since Go applications are usually statically compiled, it is hard to envision reasons for packaging Go libraries instead of just Go applications.

Sample PKGBUILDs

Sample PKGBUILD for an application written in Go

# Maintainer: NAME <EMAIL>

pkgname=PACKAGE NAME
pkgver=1.2.3
pkgrel=1
pkgdesc="PACKAGE DESCRIPTION"
arch=('x86_64' 'i686')
url="http://SERVER/$pkgname/"
license=('MIT')
makedepends=('go')
options=('!strip' '!emptydirs')
source=("http://SERVER/$pkgname/$pkgname-$pkgver.tar.gz")
sha256sums=('00112233445566778899aabbccddeeff')

build() {
  cd "$pkgname-$pkgver"

  go build
}

package() {
  cd "$pkgname-$pkgver"

  install -Dm755 "$pkgname-$pkgver" "$pkgdir/usr/bin/$pkgname"
  install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}

# vim:set ts=2 sw=2 et:

Sample packages

Sample PKGBUILD for when only a single source file is available

# Maintainer: NAME <EMAIL>

pkgname=PACKAGE NAME
pkgver=1.2.3
pkgrel=1
pkgdesc="PACKAGE DESCRIPTION"
arch=('x86_64' 'i686')
url="http://SERVER/$pkgname/"
license=('GPL3')
makedepends=('go')
options=('!strip' '!emptydirs')
source=("http://SERVER/$pkgname/$pkgname.go")
sha256sums=('00112233445566778899aabbccddeeff')

build() {
  go build -o "$pkgname"
}

package() {
  install -Dm755 "$pkgname" "$pkgdir/usr/bin/$pkgname"
}

# vim:set ts=2 sw=2 et:

Sample packages

Sample PKGBUILDs for Go libraries that also includes executables

Using go get

This is the recommended way, instead of the method below.

Here is a way that relies on go get.

You probably will not need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).

If this does not work, test with go get first.

Note: Remove /... if the PKGBUILD fails!
# Maintainer: NAME <EMAIL>

pkgname=codesearch
pkgver=20120515
pkgrel=1
pkgdesc="Code indexing and search written in Go"
arch=('x86_64' 'i686')
url="https://github.com/google/codesearch"
license=('BSD')
depends=('go')
makedepends=('mercurial')
options=('!strip' '!emptydirs')
_gourl=github.com/google/codesearch

build() {
  GOPATH="$srcdir" go get -fix -v -x ${_gourl}/...
}

check() {
  GOPATH="$GOPATH:$srcdir" go test -v -x ${_gourl}/...
}

package() {
  mkdir -p "$pkgdir/usr/bin"
  install -p -m755 "$srcdir/bin/"* "$pkgdir/usr/bin"

  mkdir -p "$pkgdir/$GOPATH"
  cp -Rv --preserve=timestamps "$srcdir/"{src,pkg} "$pkgdir/$GOPATH"

  # Package license (if available)
  for f in LICENSE COPYING LICENSE.* COPYING.*; do
    if [ -e "$srcdir/src/$_gourl/$f" ]; then
      install -Dm644 "$srcdir/src/$_gourl/$f" \
        "$pkgdir/usr/share/licenses/$pkgname/$f"
    fi
  done
}

# vim:set ts=2 sw=2 et:

Thanks to Rémy Oudompheng‎ for this one.

Using go get

Here is another way that relies on go get.

You probably will not need to modify the build() or package() functions at all, only the variables at the top (pkgname etc).

If this does not work, test with go get first.

# Maintainer: NAME <EMAIL>

pkgname=PACKAGE NAME
pkgver=1.2.3
pkgrel=1
pkgdesc="PACKAGE DESCRIPTION"
arch=('x86_64' 'i686')
url="http://SERVER/$pkgname/"
license=('MIT')
makedepends=('go' 'git')
options=('!strip' '!emptydirs')
_gourl=SERVER.NET/PATH/MODULENAME

build() {
  export GOROOT=/usr/lib/go

  rm -rf build
  mkdir -p build/go
  cd build/go

  for f in "$GOROOT/"*; do
    ln -s "$f"
  done

  rm pkg
  mkdir pkg
  cd pkg

  for f in "$GOROOT/pkg/"*; do
    ln -s "$f"
  done

  platform=`for f in "$GOROOT/pkg/"*; do echo \`basename $f\`; done|grep linux`

  rm "$platform"
  mkdir "$platform"
  cd "$platform"

  for f in "$GOROOT/pkg/$platform/"*.h; do
    ln -s "$f"
  done

  export GOROOT="$srcdir/build/go"
  export GOPATH="$srcdir/build"

  go get -fix "$_gourl"

  # Prepare executable
  if [ -d "$srcdir/build/src" ]; then
    cd "$srcdir/build/src/$_gourl"
    go build -o "$srcdir/build/$pkgname"
  else
    echo 'Old sources for a previous version of this package are already present!'
    echo 'Build in a chroot or uninstall the previous version.'
    return 1
  fi
}

package() {
  export GOROOT="$GOPATH"

  # Package go package files
  for f in "$srcdir/build/go/pkg/"* "$srcdir/build/pkg/"*; do
    # If it's a directory
    if [ -d "$f" ]; then
      cd "$f"
      mkdir -p "$pkgdir/$GOROOT/pkg/`basename $f`"
      for z in *; do
        # Check if the directory name matches
        if [ "$z" == `echo $_gourl | cut -d/ -f1` ]; then
          cp -r $z "$pkgdir/$GOROOT/pkg/`basename $f`"
        fi
      done
      cd ..
    fi
  done

  # Package source files
  if [ -d "$srcdir/build/src" ]; then
    mkdir -p "$pkgdir/$GOROOT/src/pkg"
    cp -r "$srcdir/build/src/"* "$pkgdir/$GOROOT/src/pkg/"
    find "$pkgdir" -depth -type d -name .git -exec rm -r {} \;
  fi

  # Package license (if available)
  for f in LICENSE COPYING; do
    if [ -e "$srcdir/build/src/$_gourl/$f" ]; then
      install -Dm644 "$srcdir/build/src/$_gourl/$f" \
        "$pkgdir/usr/share/licenses/$pkgname/$f"
    fi
  done

  # Package executables
  if [ -e "$srcdir/build/$pkgname" ]; then
    install -Dm755 "$srcdir/build/$pkgname" \
      "$pkgdir/usr/bin/$pkgname"
  fi
}

# vim:set ts=2 sw=2 et: