#!/bin/bash

# Copyright (c) 2018 Nicolas Mailhot <nim@fedoraproject.org>

# This file is distributed under the terms of GNU GPL license version 3, or

# any later version.

usage() {

cat >&2 << EOF_USAGE

Usage: $0 <action> [ [-h] ]

                   [ [-p <prefix>] [-g <go path>] ]

                   [ [-v <version>] ] [ [-a <attribute>] ]

<action>             should be one of: provides, requires

Most actions accept the same set of arguments, and will silently ignore those

that do not apply to a specific action. Unless specified otherwise, all

arguments are optional.

“provides”-specific arguments:

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

-a <attribute>:      an attribute to add to the provides, for example

                     -a "(commit=XXXX)"

                     -a "(branch=YYYY)"

                     -a "(tag=rx.y.z-alpha1)"

                     can be specified several times

“requires”-specific arguments:

-v <version string>: tag symbolink link target requires with <version string>

Common arguments:

-h                   print this help

-p <prefix>:         an optionnal prefix path such as %{buildroot}

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

                     default value if not set: /usr/share/gocode

EOF_USAGE

exit 1

}

action=''

version=''

prefix=''

gopath=/usr/share/gocode

declare -A attributes

if [[ $# -eq 0 ]] ; then

  usage

else case $1 in

    provides|requires) action=$1 ;;

    *)                 usage ;;

  esac

fi

shift

if ! options=$(getopt -n $0 -o hp:gv:a: \

                      -l help,prefix:,go-path: \

                      -l version:,attribute: \

                      -- "$@")

then

    usage

fi

eval set -- "$options"

while [ $# -gt 0 ] ; do

  case $1 in

    -h|--help)                      usage ;;

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

    -g|--go-path)                   gopath="$2"                  ; shift;;

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

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

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

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

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

                                    done                         ; shift;;

    (--)          shift; break;;

    (-*)          usage ;;

    (*)           break;;

  esac

  shift

done

deco=( "" )

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

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

done

# Convert paths within gopath to version-constrained provides

provides() {

 local package="${1#${prefix}${gopath}/src/}"

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

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

 done

}

# Convert paths within gopath to version-constrained requires

requires() {

  local package="${1#${prefix}${gopath}/src/}"

  echo "golang(${package})${version:+ = ${version}}"

}

# 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 target gopath

isgopathdir() {

  local lt="$1"

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

    true

  else

    false

  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/requires

#

# 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 nexttarget=$(resolvelink "$2")

  local linktarget=$(ultimateresolvelink "${nexttarget}")

  if isgopathdir "${linktarget}" ; then

    case ${action} in

      provides) 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 ;;

      requires) # Requires is not recursive — it relies on providers requiring their own needs

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

                  requires   "${subdir}"

                done

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

                  if isgopathdir $(ultimateresolvelink "${sublink}") ; then

                  # The owner of the link will declare the correct requires

                    requires "${sublink}"

                  fi

                done ;;

    esac

  fi

}

# go.attr ensures that every time a package declares owning a symlink under

# %{gopath}/src, symlink name will be piped to this script to compute the

# package Go provides/requires.

#

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

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

while read dir ; do

  if [[ -L $dir ]] ; then

    processlink "$dir" "$dir"

  fi

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