azure-cli-extensions: cleanup old scripts

#!/usr/bin/env bash

# Just a tiny imperfect helper script to commit generated updates.

#

# First, ensure that that `git add -p extensions-generated.nix` only

# returns a series of clean update hunks, where each hunk updates a

# single package version. All additions/removals must be committed

# by hand.

# The script will then commit the remaining hunks with fitting commit messages.

while true; do

  echo -e "y\nq" | git add -p extensions-generated.nix || break

  pname=$(git diff --no-ext-diff --cached | grep "pname =" | cut -d'"' -f2 | head -n1) || break

  versions=$(git diff --no-ext-diff --cached | grep "version =" | cut -d'"' -f2) || break

  oldver=$(echo "$versions" | head -n1) || break

  newver=$(echo "$versions" | tail -n1) || break

  commitmsg="azure-cli-extensions.${pname}: ${oldver} -> ${newver}"

  git commit -m "$commitmsg"

done

#!/usr/bin/env bash

set -euo pipefail

function usage() {

    {

        echo "${0} - query Azure CLI extension index"

        echo

        echo "The Azure CLI extension index contains all versions of all extensions. This"

        echo "script queries the index for the latest version of an extensions that is"

        echo "compatible with the specified version of the Azure CLI. Data for that extension"

        echo "is filtered for fields relevant to package the extension in Nix."

        echo

        echo "Usage:"

        echo "  --cli-version=<version>      version of azure-cli (required)"

        echo "  --extension=<name>           name of extension to query"

        echo "  --file=<path>                path to extension index file"

        echo "  --download                   download extension index file"

        echo "  --nix                        output Nix expression"

        echo "  --requirements=<true/false>  filter for extensions with/without requirements"

    } >&2

}

for arg in "$@"; do

    case "$arg" in

        --cli-version=*)

            cliVer="${arg#*=}"

            shift

            ;;

        --extension=*)

            extName="${arg#*=}"

            shift

            ;;

        --file=*)

            extensionFile="${arg#*=}"

            shift

            ;;

        --download)

            download=true

            shift

            ;;

        --nix)

            nix=true

            shift

            ;;

        --requirements=*)

            requirements="${arg#*=}"

            shift

            ;;

        --help)

            usage

            exit 0

            ;;

        *)

            echo "Unknown argument: $arg" >&2

            exit 1

            ;;

    esac

done

if [[ -z "${cliVer:-}" ]]; then

    echo "Missing --cli-version argument" >&2

    exit 1

fi

if [[ -z "${extensionFile:-}" && -z "${download:-}" ]]; then

    echo "Either --file or --download must be specified" >&2

    exit 1

fi

if [[ -n "${extName:-}" && -n "${requirements:-}" ]]; then

    echo "--requirements can only be used when listing all extensions" >&2

    exit 1

fi

if [[ "${download:-}" == true ]]; then

    extensionFile="$(mktemp)"

    echo "Downloading extensions index to ${extensionFile}" >&2

    curl -fsSL "https://azcliextensionsync.blob.core.windows.net/index1/index.json" > "${extensionFile}"

fi

# shellcheck disable=SC2016

jqProgram='

    def opt(f):

        . as $in | try f catch $in

        ;

    def version_to_array:

        sub("\\+.*$"; "")

        | capture("^(?<v>[^a-z-]+)(?:(?<p>.*))?") | [.v, .p // empty]

        | map(split(".")

        | map(opt(tonumber)))

        | flatten

        ;

    def version_le($contstraint):

        version_to_array as $v

        | $contstraint | version_to_array as $c

        | $v[0] < $c[0] or

          ($v[0] == $c[0] and $v[1] < $c[1]) or

          ($v[0] == $c[0] and $v[1] == $c[1] and $v[2] < $c[2]) or

          ($v[0] == $c[0] and $v[1] == $c[1] and $v[2] == $c[2] and $v[3] <= $c[3])

        ;

    def max_constrained_version($constraint):

        [

            .[] | select(.metadata."azext.minCliCoreVersion" // "0.0.0" | version_le($cliVer))

        ]

        | sort_by(.metadata.version | version_to_array)

        | last

        ;

    def translate_struct:

        {

            pname : .metadata.name,

            description: .metadata.summary,

            version: .metadata.version,

            url: .downloadUrl,

            sha256: .sha256Digest,

            license: .metadata.license,

            requires: .metadata.run_requires.[0].requires

        }

        ;

    def to_nix:

        [.].[] as $in

        | .version as $version

        | .description as $description

        | .url | sub($version;"${version}") as $url

        | $description |rtrimstr(".") as $description

        | $in.pname + " = mkAzExtension rec {\n" +

        "  pname = \"" + $in.pname + "\";\n" +

        "  version = \"" + $in.version + "\";\n" +

        "  url = \"" + $url + "\";\n" +

        "  sha256 = \"" + $in.sha256 + "\";\n" +

        "  description = \"" + $description + "\";\n" +

        "};"

        ;

    def main:

        .extensions

        | map(max_constrained_version($cliVer))

        | .[]

        | translate_struct

        | if $extName  != "" then

            select(.pname == $extName)

        elif $requirements == "false" then

            select(.requires == null)

        elif $requirements == "true" then

            select(.requires != null)

        end

        | if $nix == "true" then

            to_nix

        end

        ;

    main

'

jq -r \

    --arg cliVer "${cliVer}" \

    --arg extName "${extName:-}" \

    --arg nix "${nix:-}" \

    --arg requirements "${requirements:-}" \

    "$jqProgram" "${extensionFile}"