path: root/package.inc.sh

package_resolve() {
  local pkgbase

  [[ $pkgname ]] || log_fatal 'BUG: package_resolve called without pkgname var set'

  if package_find_remote "$1" "$2"; then
    return 0
  fi

  if pkgbase=$(archweb_get_pkgbase "$1") && package_find_remote "$pkgbase" "$2"; then
    log_info '%s is part of package %s' "$1" "$pkgbase"
    pkgname=$pkgbase
    return 0
  fi

  log_error 'unknown package: %s' "$pkgname"
  return 1
}

package_init() {
  local do_update=1

  if [[ $1 = -n ]]; then
    do_update=0
    shift
  fi

  pkgname=$1

  package_resolve "$pkgname" "$2" || return

  (( do_update )) || return 0

  if ! [[ ${!2} = packages32 ]]; then
    remote_is_tracking "${!2}" "$pkgname" ||
        remote_update_refs "${!2}" "packages/$pkgname"
  fi

  #fetch packages32/master
  #test if master exists, if not, then fetch(very slow first time)
  if ! (( OPT_UPSTREAM )); then
    git show-ref -q packages32/master || quiet_git fetch packages32 master
  fi
}

package_find_remote() {
  pkgname=$1

  # fastpath, checks local caches only
  for r in "${ARCH_GIT_REPOS[@]}"; do
    if remote_is_tracking "$r" "$pkgname"; then
      printf -v "$2" %s "$r"
      return 0
    fi
  done

  # slowpath, needs to talk to the remote
  for r in "${ARCH_GIT_REPOS[@]}"; do
    if remote_has_package "$r" "$pkgname"; then
      printf -v "$2" %s "$r"
      return 0
    fi
  done

  # arch32-only packages
  if ! (( OPT_UPSTREAM )); then
    printf -v "$2" %s "$(git ls-tree -r --name-only packages32/master \
      | awk -F/ -v pkg="${pkgname}" ' $0 ~ "/"pkg"/PKGBUILD" {print "packages32";exit}')"
    if [[ ${!2} ]]; then
      return 0
    fi
  fi

  return 1
}

package_log() {
  local method=$2 logargs remote
  pkgname=$1

  package_init "$pkgname" remote || return

  case $method in
    shortlog)
      logargs=('--pretty=oneline')
      ;;
    difflog)
      logargs=('-p')
      ;;
    log)
      logargs=()
      ;;
    *)
      log_fatal 'BUG: unknown log method: %s' "$method"
      ;;
  esac

  if ! (( OPT_UPSTREAM )); then
    repo=$(package_get_repos_with_arch "$pkgname" packages32|awk '{print $1}')
    [[ $repo ]] && git log "${logargs[@]}" "packages32/master" -- "$repo/$pkgname" \
      || log_info 'There is no Arch32 patch for %s' "$pkgname"
  else
    git log "${logargs[@]}" "$remote/packages/$pkgname" -- trunk/
  fi
}

package_show_file() {
  local file=${2:-PKGBUILD} remote repo subtree
  pkgname=$1

  if [[ $pkgname = */* ]]; then
    IFS=/ read -r repo pkgname <<<"$pkgname"
  fi

  package_init "$pkgname" remote || return

  if [[ $file != */* ]]; then
    if [[ $repo ]]; then
      subtree=repos/$repo-$OPT_ARCH/
    else
      subtree=trunk/
    fi
  fi

  git show "remotes/$remote/packages/$pkgname:$subtree$file"
}

package_list_files() {
  local remote subtree=trunk
  pkgname=$1

  if [[ $pkgname = */* ]]; then
    IFS=/ read -r repo pkgname <<<"$pkgname"
  fi

  package_init "$pkgname" remote || return

  if [[ $repo ]]; then
    subtree=repos/$repo-$OPT_ARCH
  fi


  git ls-tree -r --name-only "remotes/$remote/packages/$pkgname" "$subtree" |
      awk -v "prefix=$subtree/" 'sub(prefix, "")'
}

package_patch_arch32() {
  local arch repo subtree
  read -r repo arch < <(package_get_repos_with_arch "$pkgname" "$remote" \
    | awk '!/testing/ && (/x86_64/ || /arch32/ || /any/) {print $1" "$2; exit}')
  subtree=${1:-repos/${repo}-${arch}}
  mkdir -p ${pkgname}/${subtree} && touch ${pkgname}/${subtree}/PKGBUILD
  awk -i inplace '!/^arch=[^#]*any/ {gsub(/^arch=\(/,"arch=(i486 i686 pentium3 ")}; {print}' \
    "$pkgname/${subtree}/PKGBUILD"
  for line in $(git ls-tree -r --name-only remotes/packages32/master ${repo}/${pkgname}); do
    if [[ "${line##*/}" = "PKGBUILD" ]]; then
      git show remotes/packages32/master:${line} >> ${pkgname}/${subtree}/PKGBUILD
    else
      git show remotes/packages32/master:${line} > ${pkgname}/${subtree}/${line##*/}
    fi
  done
}

package_export() {
  local remote repo arch path subtree=trunk
  pkgname=$1

  if [[ $pkgname = */* ]]; then
    IFS=/ read -r repo pkgname <<<"$pkgname"
  fi

  package_init "$pkgname" remote || return

  if [[ $repo ]]; then
    subtree=repos/$repo-$OPT_ARCH
  fi

  if ! [[ $remote = packages32 ]]; then
    if ! git show "remotes/$remote/packages/$pkgname:$subtree/" &>/dev/null; then
      if [[ $repo ]]; then
        log_error "package '%s' not found in repo '%s-%s'" "$pkgname" "$repo" "$OPT_ARCH"
        return 1
      else
        log_error "package '%s' has no trunk directory!" "$pkgname"
        return 1
      fi
    fi

    if (( ! OPT_FORCE )); then
      # shellcheck disable=SC2154
      mkdir "$pkgname" || return
    fi

    log_info 'exporting %s:%s' "$pkgname" "$subtree"
    git archive --format=tar "remotes/$remote/packages/$pkgname" "$subtree/" |
        tar --transform "s,^$subtree,$pkgname," -xf - "$subtree/"
  fi

  if ! (( OPT_UPSTREAM )); then
    package_patch_arch32 .
  fi
}

package_checkout() {
  local remote
  pkgname=$1

  package_init "$pkgname" remote || return

  if ! [[ $remote = packages32 ]]; then
    git show-ref -q "refs/heads/$remote/packages/$pkgname" ||
        git branch -qf --no-track {,}"$remote/packages/$pkgname"

    quiet_git clone \
      --shared \
      --single-branch \
      --branch "$remote/packages/$pkgname" \
      --config "pull.rebase=true" \
      "$ASPROOT" "$pkgname" || return
  fi

  if ! (( OPT_UPSTREAM )); then
    package_patch_arch32
  fi
}

package_get_repos_with_arch() {
  local remote=$2 path arch repo
  pkgname=$1

  if [[ $remote == packages32 ]]; then
    repo="$(git ls-tree -r --name-only packages32/master \
      | awk -F/ -v pkg="${pkgname}" ' $0 ~ "/"pkg"/PKGBUILD" {print $1;exit}')"
    [[ $repo ]] && arch=arch32
    printf '%s %s\n' "$repo" "$arch"
  else
    while read -r path; do
      path=${path##*/}
      repo=${path%-*}
      arch=${path##*-}
      printf '%s %s\n' "$repo" "$arch"
    done < <(git ls-tree --name-only "remotes/$remote/packages/$pkgname" repos/)
  fi

}

package_get_arches() {
  local remote arch
  declare -A arches
  pkgname=$1

  package_init "$pkgname" remote || return

  while read -r _ arch; do
    arches["$arch"]=1
  done < <(package_get_repos_with_arch "$pkgname" "$remote")

  printf '%s\n' "${!arches[@]}"
}

package_get_repos() {
  local remote repo
  declare -A repos
  pkgname=$1

  package_init "$pkgname" remote || return

  while read -r repo _; do
    repos["$repo"]=1
  done < <(package_get_repos_with_arch "$pkgname" "$remote")

  printf '%s\n' "${!repos[@]}"
}

package_untrack() {
  local remote=$2
  pkgname=$1

  if git show-ref -q "refs/heads/$remote/packages/$pkgname"; then
    git branch -D "$remote/packages/$pkgname"
  fi
}