Ignore:
Timestamp:
2024-03-14T16:34:12+01:00 (13 months ago)
Author:
taylor.smock
Message:

StreetSide: Update to official API

This also moves the plugin to Java 21 (mostly for virtual threads), reformats the
code to match the JOSM standard (4 spaces), and fixes a bunch of lint issues.

Additionally, a lot of cruft from when this plugin was copied from Mapillary was
removed. That was largely related to image import, uploading, and login.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/MicrosoftStreetside/gradlew

    r36194 r36228  
    1 #!/usr/bin/env sh
    2 
    3 #
    4 # Copyright 2015 the original author or authors.
     1#!/bin/sh
     2
     3#
     4# Copyright © 2015-2021 the original authors.
    55#
    66# Licensed under the Apache License, Version 2.0 (the "License");
    … …  
    1818
    1919##############################################################################
    20 ##
    21 ##  Gradle start up script for UN*X
    22 ##
     20#
     21#   Gradle start up script for POSIX generated by Gradle.
     22#
     23#   Important for running:
     24#
     25#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
     26#       noncompliant, but you have some other compliant shell such as ksh or
     27#       bash, then to run this script, type that shell name before the whole
     28#       command line, like:
     29#
     30#           ksh Gradle
     31#
     32#       Busybox and similar reduced shells will NOT work, because this script
     33#       requires all of these POSIX shell features:
     34#         * functions;
     35#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
     36#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
     37#         * compound commands having a testable exit status, especially «case»;
     38#         * various built-in commands including «command», «set», and «ulimit».
     39#
     40#   Important for patching:
     41#
     42#   (2) This script targets any POSIX shell, so it avoids extensions provided
     43#       by Bash, Ksh, etc; in particular arrays are avoided.
     44#
     45#       The "traditional" practice of packing multiple parameters into a
     46#       space-separated string is a well documented source of bugs and security
     47#       problems, so this is (mostly) avoided, by progressively accumulating
     48#       options in "$@", and eventually passing that to Java.
     49#
     50#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
     51#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
     52#       see the in-line comments for details.
     53#
     54#       There are tweaks for specific operating systems such as AIX, CygWin,
     55#       Darwin, MinGW, and NonStop.
     56#
     57#   (3) This script is generated from the Groovy template
     58#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
     59#       within the Gradle project.
     60#
     61#       You can find Gradle at https://github.com/gradle/gradle/.
     62#
    2363##############################################################################
    2464
    2565# Attempt to set APP_HOME
     66
    2667# Resolve links: $0 may be a link
    27 PRG="$0"
    28 # Need this for relative symlinks.
    29 while [ -h "$PRG" ] ; do
    30     ls=`ls -ld "$PRG"`
    31     link=`expr "$ls" : '.*-> \(.*\)$'`
    32     if expr "$link" : '/.*' > /dev/null; then
    33         PRG="$link"
    34     else
    35         PRG=`dirname "$PRG"`"/$link"
    36     fi
     68app_path=$0
     69
     70# Need this for daisy-chained symlinks.
     71while
     72    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
     73    [ -h "$app_path" ]
     74do
     75    ls=$( ls -ld "$app_path" )
     76    link=${ls#*' -> '}
     77    case $link in             #(
     78      /*)   app_path=$link ;; #(
     79      *)    app_path=$APP_HOME$link ;;
     80    esac
    3781done
    38 SAVED="`pwd`"
    39 cd "`dirname \"$PRG\"`/" >/dev/null
    40 APP_HOME="`pwd -P`"
    41 cd "$SAVED" >/dev/null
    42 
    43 APP_NAME="Gradle"
    44 APP_BASE_NAME=`basename "$0"`
    45 
    46 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
    47 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
     82
     83# This is normally unused
     84# shellcheck disable=SC2034
     85APP_BASE_NAME=${0##*/}
     86# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
     87APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
    4888
    4989# Use the maximum available, or set MAX_FD != -1 to use that value.
    50 MAX_FD="maximum"
     90MAX_FD=maximum
    5191
    5292warn () {
    5393    echo "$*"
    54 }
     94} >&2
    5595
    5696die () {
    … …  
    5999    echo
    60100    exit 1
    61 }
     101} >&2
    62102
    63103# OS specific support (must be 'true' or 'false').
    … …  
    66106darwin=false
    67107nonstop=false
    68 case "`uname`" in
    69   CYGWIN* )
    70     cygwin=true
    71     ;;
    72   Darwin* )
    73     darwin=true
    74     ;;
    75   MSYS* | MINGW* )
    76     msys=true
    77     ;;
    78   NONSTOP* )
    79     nonstop=true
    80     ;;
     108case "$( uname )" in                #(
     109  CYGWIN* )         cygwin=true  ;; #(
     110  Darwin* )         darwin=true  ;; #(
     111  MSYS* | MINGW* )  msys=true    ;; #(
     112  NONSTOP* )        nonstop=true ;;
    81113esac
    82114
    … …  
    88120    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
    89121        # IBM's JDK on AIX uses strange locations for the executables
    90         JAVACMD="$JAVA_HOME/jre/sh/java"
     122        JAVACMD=$JAVA_HOME/jre/sh/java
    91123    else
    92         JAVACMD="$JAVA_HOME/bin/java"
     124        JAVACMD=$JAVA_HOME/bin/java
    93125    fi
    94126    if [ ! -x "$JAVACMD" ] ; then
    … …  
    99131    fi
    100132else
    101     JAVACMD="java"
    102     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
     133    JAVACMD=java
     134    if ! command -v java >/dev/null 2>&1
     135    then
     136        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
    103137
    104138Please set the JAVA_HOME variable in your environment to match the
    105139location of your Java installation."
     140    fi
    106141fi
    107142
    108143# Increase the maximum file descriptors if we can.
    109 if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
    110     MAX_FD_LIMIT=`ulimit -H -n`
    111     if [ $? -eq 0 ] ; then
    112         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
    113             MAX_FD="$MAX_FD_LIMIT"
     144if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     145    case $MAX_FD in #(
     146      max*)
     147        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
     148        # shellcheck disable=SC2039,SC3045
     149        MAX_FD=$( ulimit -H -n ) ||
     150            warn "Could not query maximum file descriptor limit"
     151    esac
     152    case $MAX_FD in  #(
     153      '' | soft) :;; #(
     154      *)
     155        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
     156        # shellcheck disable=SC2039,SC3045
     157        ulimit -n "$MAX_FD" ||
     158            warn "Could not set maximum file descriptor limit to $MAX_FD"
     159    esac
     160fi
     161
     162# Collect all arguments for the java command, stacking in reverse order:
     163#   * args from the command line
     164#   * the main class name
     165#   * -classpath
     166#   * -D...appname settings
     167#   * --module-path (only if needed)
     168#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
     169
     170# For Cygwin or MSYS, switch paths to Windows format before running java
     171if "$cygwin" || "$msys" ; then
     172    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
     173    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
     174
     175    JAVACMD=$( cygpath --unix "$JAVACMD" )
     176
     177    # Now convert the arguments - kludge to limit ourselves to /bin/sh
     178    for arg do
     179        if
     180            case $arg in                                #(
     181              -*)   false ;;                            # don't mess with options #(
     182              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
     183                    [ -e "$t" ] ;;                      #(
     184              *)    false ;;
     185            esac
     186        then
     187            arg=$( cygpath --path --ignore --mixed "$arg" )
    114188        fi
    115         ulimit -n $MAX_FD
    116         if [ $? -ne 0 ] ; then
    117             warn "Could not set maximum file descriptor limit: $MAX_FD"
    118         fi
    119     else
    120         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
    121     fi
    122 fi
    123 
    124 # For Darwin, add options to specify how the application appears in the dock
    125 if $darwin; then
    126     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
    127 fi
    128 
    129 # For Cygwin or MSYS, switch paths to Windows format before running java
    130 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
    131     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    132     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    133 
    134     JAVACMD=`cygpath --unix "$JAVACMD"`
    135 
    136     # We build the pattern for arguments to be converted via cygpath
    137     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
    138     SEP=""
    139     for dir in $ROOTDIRSRAW ; do
    140         ROOTDIRS="$ROOTDIRS$SEP$dir"
    141         SEP="|"
     189        # Roll the args list around exactly as many times as the number of
     190        # args, so each arg winds up back in the position where it started, but
     191        # possibly modified.
     192        #
     193        # NB: a `for` loop captures its iteration list before it begins, so
     194        # changing the positional parameters here affects neither the number of
     195        # iterations, nor the values presented in `arg`.
     196        shift                   # remove old arg
     197        set -- "$@" "$arg"      # push replacement arg
    142198    done
    143     OURCYGPATTERN="(^($ROOTDIRS))"
    144     # Add a user-defined pattern to the cygpath arguments
    145     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
    146         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
    147     fi
    148     # Now convert the arguments - kludge to limit ourselves to /bin/sh
    149     i=0
    150     for arg in "$@" ; do
    151         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
    152         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
    153 
    154         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
    155             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
    156         else
    157             eval `echo args$i`="\"$arg\""
    158         fi
    159         i=`expr $i + 1`
    160     done
    161     case $i in
    162         0) set -- ;;
    163         1) set -- "$args0" ;;
    164         2) set -- "$args0" "$args1" ;;
    165         3) set -- "$args0" "$args1" "$args2" ;;
    166         4) set -- "$args0" "$args1" "$args2" "$args3" ;;
    167         5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
    168         6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
    169         7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
    170         8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
    171         9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    172     esac
    173 fi
    174 
    175 # Escape application args
    176 save () {
    177     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
    178     echo " "
    179 }
    180 APP_ARGS=`save "$@"`
    181 
    182 # Collect all arguments for the java command, following the shell quoting and substitution rules
    183 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
     199fi
     200
     201
     202# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
     203DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
     204
     205# Collect all arguments for the java command:
     206#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
     207#     and any embedded shellness will be escaped.
     208#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
     209#     treated as '${Hostname}' itself on the command line.
     210
     211set -- \
     212        "-Dorg.gradle.appname=$APP_BASE_NAME" \
     213        -classpath "$CLASSPATH" \
     214        org.gradle.wrapper.GradleWrapperMain \
     215        "$@"
     216
     217# Stop when "xargs" is not available.
     218if ! command -v xargs >/dev/null 2>&1
     219then
     220    die "xargs is not available"
     221fi
     222
     223# Use "xargs" to parse quoted args.
     224#
     225# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
     226#
     227# In Bash we could simply go:
     228#
     229#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
     230#   set -- "${ARGS[@]}" "$@"
     231#
     232# but POSIX shell has neither arrays nor command substitution, so instead we
     233# post-process each arg (as a line of input to sed) to backslash-escape any
     234# character that might be a shell metacharacter, then use eval to reverse
     235# that process (while maintaining the separation between arguments), and wrap
     236# the whole thing up as a single "set" statement.
     237#
     238# This will of course break if any of these variables contains a newline or
     239# an unmatched quote.
     240#
     241
     242eval "set -- $(
     243        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
     244        xargs -n1 |
     245        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
     246        tr '\n' ' '
     247    )" '"$@"'
    184248
    185249exec "$JAVACMD" "$@"
Note: See TracChangeset for help on using the changeset viewer.