#!/bin/bash

usage() {

cat >&2 << EOF_USAGE

Usage: $0 -g <go import path> [-p <prefix>] [-G <go path>] [-v <version string>] [-a <attributes>]

<go import path>   the Go import path of the target package

<prefix>:          an eventual prefix path such as %{buildroot}

<go path>:         the root of the Go source tree

<version string>:  tag the provides with the <version string>

<attributes>:      attributes to add to the provides, for example

                   (commit=XXXX)(branch=YYYY) or

                   (vermod=alpha1)

Example:

echo filename | $0 -g golang.org/x/net -G /usr/share/gocode -v 2.5-0.1

echo filename | $0 -g golang.org/x/net -a '(commit=XXXX)(branch=YYYY)'

echo filename | $0 -g golang.org/x/net -a '(vermod=alpha1)'

EOF_USAGE

exit 1

}

if ! options=$(getopt -n $0 -o hg:p:G:v:a: -l help,goipath:,prefix:,gopath:,version:,attr:,attribute:,attributes: -- "$@")

then

    # something went wrong, getopt will put out an error message for us

    exit 2

fi

eval set -- "$options"

# Convert paths within gopath to version-constrained provides

# Never call it before checking the path belongs to the package import path

provides() {

  local ppath="$1"

  # Check for a vendor root, when not processing a symlink

  if ! ( [[ -L "${ppath}" ]] || ( notvendored "${ppath}" ) ) ; then

    local vroot="$(realpath -sm "${ppath}")/"

    vroot="${vroot%/vendor/*}/vendor"

    if [[ "${vroot}" != "${ppath}" ]] ; then

      # Check if a parent with files exists within the vendor root

      local tip="${ppath}"

      local vipath=/dev/null

      until [[ "${tip}" == "${vroot}" || "${ppath}" == "${vipath}/"* ]] ; do

        [[ -n $(find "$tip" -maxdepth 1 -type f) ]] && vipath="$tip"

        tip=$(dirname "$tip")

      done

      # If we didn't find a parent with files other than the path itself, it is

      # the vendored import path root!

      if [[ "$vipath" == "$ppath" ]] ; then

        echo "bundled(golang(${ppath##*/vendor/}))"

      fi

    fi

  else

    local package="${ppath#${root}/src/}"

    for index in "${!deco[@]}" ; do

      echo "golang(${package})${deco[index]}${version}"

    done

  fi

}

# Resolve a symlink target in presence of a build root

resolvelink() {

  local lt=$(realpath -m "$1")

  echo "${prefix}${lt#${prefix}}"

}

# Resolve a symlink to its ultimate target in presence of a build root

ultimateresolvelink() {

  local lt="$1"

  until [[ ! -L ${lt} ]] ; do

    lt=$(resolvelink "${lt}")

  done

  echo "${lt}"

}

# Test if a path is a directory within the package import path.

isgoipathdir() {

  local lt="$1"

  if [[ -d ${lt} ]] && [[ "${lt}"/ == "${root}/src/${goipath}"/* ]] ; then

    true

  else

    false

  fi

}

# Test if a path is vendored

notvendored() {

  local p=$(realpath -sm "$1")

  local vr="${p}/"

  vr="${vr%/vendor/*}"

  if [[ "${vr}" != "${p}/" ]] ; then

    false

  else

    true

  fi

}

# A symlink can point to a whole directory tree, but go.attr will only

# trigger on the root symlink.

# Therefore, check the symlink points within the processed import path, then

# walk all the target tree to generate symlink provides

#

# To process nested symlinks the function needs to be provided a working path

# to the symlink tip within the build root as second argument.

processlink() {

  local link="$1"

  local linktarget=$(ultimateresolvelink "$2")

  if ( isgoipathdir "${linktarget}" ) && ( notvendored "${linktarget}" ) ; then

    find "${linktarget}" -type d -print | while read subdir ; do

      provides    "${link}${subdir#${linktarget}}"

    done

    find "${linktarget}" -type l -print | while read sublink ; do

      processlink "${link}${sublink#${linktarget}}" "${sublink}"

    done

  fi

}

version=''

prefix=''

gopath=/usr/share/gocode

declare -A attributes

while [ $# -gt 0 ] ; do

  case $1 in

    -h|--help)    usage ;;

    -g|--goipath) goipath="$2" ; shift;;

    -p|--prefix)  prefix=$(realpath -sm "$2") ; shift;;

    -G|--gopath)  gopath="$2" ; shift;;

    -v|--version) version=" = $2" ; shift;;

    -a|--attr|--attribute|--attributes)

                  IFS=')' read -r -a newattrs <<< "$2"

                  for index in "${!newattrs[@]}" ; do

                    newattrs[index]=${newattrs[index]#\(}

                    attributes[${newattrs[index]%%=*}]=${newattrs[index]#*=}

                  done ; shift;;

    (--)          shift; break;;

    (-*)          echo "$0: error - unrecognized option $1" >&2; exit 3;;

    (*)           break;;

  esac

  shift

done

# Detection of the package import path root is necessary to insure we do not

# generate useless provides such as golang(github).

#

# When go dep stabilizes and can be generalized import path root detection may

# be automated by searching for the first level of go dep lock files.

#

# However the requirement to set %{goipath} may remain to make sure we avoid

# processing directories created without applying the sanity checks documented

# in Fedora Packaging Guidelines.

[[ -z ${goipath} ]] && exit 0

root="${prefix}${gopath}"

deco=( "" )

# Some filtering may be needed in the future

for key in "${!attributes[@]}"; do

  [ -n "${attributes[$key]}" ] && deco+=( "($key=${attributes[$key]})" )

done

# go.attr ensures that every time a package declares owning a directory or

# symlink under %{gopath}/src, the directory or symlink name will be piped to

# this script to compute the package Go provides.

#

# For legacy reason the script is supposed to be able to handle multiple

# inputs, even though modern rpm invokes it separately for each directory.

#

# As native Go tooling is focused on leaf developer needs (“what I need from

# others to build my code”, not “what I provide to help others build their

# code”) Go auto-provides do not invoke any Go binary and just record all the

# directories created under the import path root. This is actually faster and

# more reliable, since Go project seem to import pretty much any import path

# subdirectory, even if it contains assets without any .go file.

while read dir ; do

  if [[ -L $dir ]] ; then

    processlink "$dir" "$dir"

  else

    # If go.attr triggered on a normal directory just make sure it is under the

    # package import path, then provide it

    if [[ -d $dir ]] ; then

      dir=$(realpath -sm "$dir")

      [[ "${dir}"/ == "${root}/src/${goipath}"/* ]] && provides "$dir"

    fi

  fi

done | sort | uniq | grep -v '/\([._]\)\?\(internal\|vendor\)\([/)]\)'