fastlane-plugin-waldo 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa67171d14f9daf43bb1e2d64b6b2add082b014b3bc9063f6c6d89f94f12bce6
-  data.tar.gz: 506bbdf57902a6bc9eb53de9ec511dc9402db1f4b186a436b3596f583506e1ff
+  metadata.gz: dd88e9f3a32bde7a83c70b6988a3683af7c896cc57a63f6d77942265eb7517fe
+  data.tar.gz: a1f9c1fda4daf3705237de99eafa7bc2de6486a939e7545234a3792ab1a89b9b
 SHA512:
-  metadata.gz: e5b75644e5a86cb924bcc0d6c83e0421b16ac165ab8eacbbe35abc0eaef34235f590949a1466a3b0bc2e6fd96da799dcc7c08a1ba4cd51ed45051d5f0cb89817
-  data.tar.gz: f421167cc09941741c7e7fc368b6a771839108d200184e0e41bf47be09ee44df958e6534f9595d9860204e3ddd2fa0bf9e5bfb022d7fae2415c9ed1c73dac2a9
+  metadata.gz: 3e0613f158f9d570bbb1a0314f5cf1c16fe5d6976ea8abd2ab3ac686249ee47a4624e6b74fcaa4bf369846fa1bf9343131c16a9916fc4f062b2d14b7a56e7907
+  data.tar.gz: daf65861ab2f031479f0e713f217b68686dd0133f619c1d7fb24b1dd4d9acb403da6781aa799dfbc58a5bae5432faa65e4df40e512a38aafa90639916e58afd5

data/README.md

@@ -38,8 +38,7 @@ gym(configuration: 'Release',
     destination: 'generic/platform=iOS Simulator')
 ```
 
-You can then find your app (and associated symbols) relative to the derived
-data path:
+You can then find your app relative to the derived data path:
 
 ```ruby
 app_path = File.join(derived_data_path,
@@ -54,13 +53,11 @@ upload itself is very simple:
 
 ```ruby
 waldo(upload_token: '0123456789abcdef0123456789abcdef',
-      app_path: '/path/to/YourApp.app',
-      include_symbols: true)
+      app_path: '/path/to/YourApp.app')
 ```
 
 > **Note:** You _must_ specify _both_ the Waldo upload token _and_ the path of
-> the `.app`. The `include_symbols` parameter is optional but we highly
-> recommend supplying it.
+> the `.app`.
 
 ### Uploading an iOS Device Build
 
@@ -70,20 +67,17 @@ your IPA, `waldo` will automatically find and upload the generated IPA.
 ```ruby
 gym(export_method: 'ad-hoc')                            # or 'development'
 
-waldo(upload_token: '0123456789abcdef0123456789abcdef',
-      dsym_path: lane_context[SharedValues::DSYM_OUTPUT_PATH])
+waldo(upload_token: '0123456789abcdef0123456789abcdef')
 ```
 
-> **Note:** You _must_ specify the Waldo upload token. The `dsym_path`
-> parameter is optional but we highly recommend supplying it.
+> **Note:** You _must_ specify the Waldo upload token.
 
 If you do _not_ use `gym` to build your IPA, you will need to explicitly
 specify the IPA path to `waldo`:
 
 ```ruby
 waldo(upload_token: '0123456789abcdef0123456789abcdef',
-      ipa_path: '/path/to/YourApp.ipa',
-      dsym_path: '/path/to/YourApp.app.dSYM.zip')
+      ipa_path: '/path/to/YourApp.ipa')
 ```
 
 ### Uploading an Android Build

data/lib/fastlane/plugin/waldo/actions/waldo_action.rb

@@ -7,7 +7,7 @@ module Fastlane
         FastlaneCore::PrintTable.print_values(config: mparams,
                                               title: "Summary for waldo #{Fastlane::Waldo::VERSION.to_s}")
 
-        Helper::WaldoHelper.upload_build_with_symbols(mparams)
+        Helper::WaldoHelper.upload_build(mparams)
       end
 
       def self.authors
@@ -27,16 +27,6 @@ module Fastlane
                                        default_value: Actions.lane_context[Actions::SharedValues::IPA_OUTPUT_PATH],
                                        default_value_dynamic: true,
                                        optional: true),
-          FastlaneCore::ConfigItem.new(key: :dsym_path,
-                                       env_name: 'WALDO_DSYM_PATH',
-                                       description: 'Path to your dSYM file(s)',
-                                       optional: true),
-          FastlaneCore::ConfigItem.new(key: :include_symbols,
-                                       env_name: 'WALDO_INCLUDE_SYMBOLS',
-                                       description: 'Include symbols in upload if true',
-                                       optional: true,
-                                       default_value: false,
-                                       is_string: false),
           # Android-specific
           FastlaneCore::ConfigItem.new(key: :apk_path,
                                        env_name: 'WALDO_APK_PATH',
@@ -47,14 +37,21 @@ module Fastlane
           # General
           FastlaneCore::ConfigItem.new(key: :upload_token,
                                        env_name: 'WALDO_UPLOAD_TOKEN',
-                                       description: 'Waldo upload token',
+                                       description: 'Upload token',
                                        optional: true,
                                        sensitive: true),
           FastlaneCore::ConfigItem.new(key: :variant_name,
                                        env_name: 'WALDO_VARIANT_NAME',
-                                       description: 'Waldo variant name',
-                                       optional: true,
-                                       sensitive: true)
+                                       description: 'Variant name',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :git_branch,
+                                       env_name: 'WALDO_GIT_BRANCH',
+                                       description: 'Branch name for originating git commit',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :git_commit,
+                                       env_name: 'WALDO_GIT_COMMIT',
+                                       description: 'Hash of originating git commit',
+                                       optional: true)
         ]
       end
 

data/lib/fastlane/plugin/waldo/helper/waldo_helper.rb

@@ -6,15 +6,14 @@ module Fastlane
 
         apk_path = in_params[:apk_path]
         app_path = in_params[:app_path]
-        dsym_path = in_params[:dsym_path]
-        include_symbols = in_params[:include_symbols]
+        git_branch = in_params[:git_branch]
+        git_commit = in_params[:git_commit]
         ipa_path = in_params[:ipa_path]
         upload_token = in_params[:upload_token]
         variant_name = in_params[:variant_name] || Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
 
         apk_path.gsub!("\\ ", ' ') if apk_path
         app_path.gsub!("\\ ", ' ') if app_path
-        dsym_path.gsub!("\\ ", ' ') if dsym_path
         ipa_path.gsub!("\\ ", ' ') if ipa_path
 
         out_params[:apk_path] = apk_path if apk_path
@@ -42,72 +41,88 @@ module Fastlane
           out_params[:ipa_path] = ipa_path if ipa_path
         end
 
-        if app_path
-            out_params[:dsym_path] = dsym_path if dsym_path
-            out_params[:include_symbols] = include_symbols if include_symbols
-        else
-            out_params[:dsym_path] = dsym_path if dsym_path && ipa_path
-        end
-
+        out_params[:git_branch] = git_branch if git_branch
+        out_params[:git_commit] = git_commit if git_commit
         out_params[:upload_token] = upload_token if upload_token
         out_params[:variant_name] = variant_name if variant_name
 
         out_params
       end
 
-      def self.get_flavor
-        case get_platform
-        when :android
-          'Android'
-        when :ios
-          'iOS'
+      def self.get_binary_path
+        platform = RUBY_PLATFORM.downcase
+
+        if platform.include?("linux")
+          ext = ""
+          os = "linux"
+        elsif platform.include?("darwin")
+          ext = ""
+          os = "macos"
+        elsif platform.include?("mswin")
+          ext = ".exe"
+          os = "windows"
         else
-          'unknown'
+          UI.error("Unsupported platform: #{platform}")
         end
-      end
 
-      def self.get_platform
-        Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] || :ios
-      end
+        if platform.include?("arm64")
+          arch = "arm64"
+        elsif platform.include?("x86_64")
+          arch = "x86_64"
+        else
+          UI.error("Unsupported platform: #{platform}")
+        end
 
-      def self.get_script_path
         root = Pathname.new(File.expand_path('../../..', __FILE__))
 
-        File.join(root, 'waldo', 'assets', 'WaldoCLI.sh')
-      end
-
-      def self.get_user_agent
-        "Waldo fastlane/#{get_flavor} v#{Fastlane::Waldo::VERSION}"
+        File.join(root, "waldo", "assets", "waldo-#{os}-#{arch}#{ext}")
       end
 
-      def self.upload_build_with_symbols(params)
+      def self.upload_build(params)
         apk_path = params[:apk_path]
         app_path = params[:app_path]
         ipa_path = params[:ipa_path]
 
         if apk_path
-            build_path = apk_path
+          build_path = apk_path
         elsif app_path
-            build_path = app_path
+          build_path = app_path
         elsif ipa_path
-            build_path = ipa_path
+          build_path = ipa_path
         else
-            build_path = ""
+          build_path = ""
         end
 
         command = []
 
-        command << "WALDO_UPLOAD_TOKEN='#{params[:upload_token]}'"
-        command << "WALDO_USER_AGENT_OVERRIDE='#{get_user_agent}'"
-        command << "WALDO_VARIANT_NAME='#{params[:variant_name]}'" if params[:variant_name]
+        command << "WALDO_WRAPPER_NAME_OVERRIDE='Fastlane'"
+        command << "WALDO_WRAPPER_VERSION_OVERRIDE='#{Fastlane::Waldo::VERSION}'"
 
-        command << get_script_path.shellescape
+        command << get_binary_path.shellescape
+
+        if params[:git_branch]
+          command << '--git_branch'
+          command << params[:git_branch]
+        end
+
+        if params[:git_commit]
+          command << '--git_commit'
+          command << params[:git_commit]
+        end
+
+        if params[:upload_token]
+          command << '--upload_token'
+          command << params[:upload_token]
+        end
+
+        if params[:variant_name]
+          command << '--variant_name'
+          command << params[:variant_name]
+        end
 
-        command << '--include_symbols' if params[:include_symbols]
         command << '--verbose' if FastlaneCore::Globals.verbose?
 
         command << build_path.shellescape
-        command << params[:dsym_path].shellescape if params[:dsym_path]
 
         Actions.sh_control_output(command.join(' '),
                                   print_command: FastlaneCore::Globals.verbose?,

data/lib/fastlane/plugin/waldo/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Waldo
-    VERSION = "2.0.1"
+    VERSION = "3.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-waldo
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
-- J. G. Pusey
+- John Pusey
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-14 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,7 +76,12 @@ files:
 - README.md
 - lib/fastlane/plugin/waldo.rb
 - lib/fastlane/plugin/waldo/actions/waldo_action.rb
-- lib/fastlane/plugin/waldo/assets/WaldoCLI.sh
+- lib/fastlane/plugin/waldo/assets/waldo-linux-arm64
+- lib/fastlane/plugin/waldo/assets/waldo-linux-x86_64
+- lib/fastlane/plugin/waldo/assets/waldo-macos-arm64
+- lib/fastlane/plugin/waldo/assets/waldo-macos-x86_64
+- lib/fastlane/plugin/waldo/assets/waldo-windows-arm64.exe
+- lib/fastlane/plugin/waldo/assets/waldo-windows-x86_64.exe
 - lib/fastlane/plugin/waldo/helper/waldo_helper.rb
 - lib/fastlane/plugin/waldo/version.rb
 homepage: https://github.com/waldoapp/fastlane-plugin-waldo

data/lib/fastlane/plugin/waldo/assets/WaldoCLI.sh

@@ -1,672 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu -o pipefail
-
-waldo_api_build_endpoint=${WALDO_API_BUILD_ENDPOINT:-https://api.waldo.io/versions}
-waldo_api_error_endpoint=${WALDO_API_ERROR_ENDPOINT:-https://api.waldo.io/uploadError}
-waldo_api_symbols_endpoint=${WALDO_API_SYMBOLS_ENDPOINT:-https://api.waldo.io/versions/__ID__/symbols}
-waldo_user_agent_override=${WALDO_USER_AGENT_OVERRIDE:-}
-
-waldo_cli_version="1.6.6"
-
-waldo_build_flavor=""
-waldo_build_path=""
-waldo_build_payload_path=""
-waldo_build_suffix=""
-waldo_build_upload_id=""
-waldo_extra_args="--show-error --silent"
-waldo_history=""
-waldo_history_error=""
-waldo_include_symbols=false
-waldo_platform=""
-waldo_symbols_path=""
-waldo_symbols_payload_path=""
-waldo_symbols_suffix=""
-waldo_upload_token=""
-waldo_variant_name=""
-waldo_working_path=""
-
-function abs_path() {
-    local _rel_path=$1
-
-    [[ -n $_rel_path ]] || _rel_path="."
-
-    case "$_rel_path" in
-        .)  pwd ;;
-        ..) (unset CDPATH && cd .. &>/dev/null && pwd) ;;
-        /*) echo $_rel_path ;;
-        *)  local _dirname=$(dirname "$_rel_path")
-
-            _dirname=$(unset CDPATH && cd "$_dirname" &>/dev/null && pwd)
-
-            if [[ -n $_dirname ]]; then
-                echo ${_dirname}/$(basename "$_rel_path")
-            else
-                echo $_rel_path
-            fi
-            ;;
-    esac
-}
-
-function check_build_path() {
-    [[ -n $waldo_build_path ]] || fail_usage "Missing required argument: ‘path’"
-
-    waldo_build_path=$(abs_path "$waldo_build_path")
-    waldo_build_suffix=${waldo_build_path##*.}
-
-    case $waldo_build_suffix in
-        apk)     waldo_build_flavor="Android" ;;
-        app|ipa) waldo_build_flavor="iOS" ;;
-        *)       fail "File extension of build at ‘${waldo_build_path}’ is not recognized" ;;
-    esac
-}
-
-function check_build_status() {
-    local _response=$1
-
-    local _status_regex='"status":([0-9]+)'
-
-    if [[ $_response =~ $_status_regex ]]; then
-        local _status=${BASH_REMATCH[1]}
-
-        if (( $_status == 401 )); then
-            fail "Upload token is invalid or missing!"
-        elif (( $_status < 200 || $_status > 299 )); then
-            fail "Unable to upload build to Waldo, HTTP status: $_status"
-        fi
-    fi
-
-    local _id_regex='"id":"(appv-[0-9a-f]+)"'
-
-    if [[ $_response =~ $_id_regex ]]; then
-        waldo_build_upload_id=${BASH_REMATCH[1]}
-    fi
-}
-
-function check_history() {
-    if [[ -z $(which base64) ]]; then
-        waldo_history_error="noBase64CommandFound"
-    elif [[ -z $(which git) ]]; then
-        waldo_history_error="noGitCommandFound"
-    elif [[ -z $(which grep) ]]; then
-        waldo_history_error="noGrepCommandFound"
-    elif [[ -z $(which sed) ]]; then
-        waldo_history_error="noSedCommandFound"
-    elif [[ -z $(which tr) ]]; then
-        waldo_history_error="noTrCommandFound"
-    elif ! git rev-parse >& /dev/null; then
-        waldo_history_error="notGitRepository"
-    else
-        waldo_history=$(get_history)
-    fi
-}
-
-function check_platform() {
-    if [[ -z $(which curl) ]]; then
-        fail "No ‘curl’ command found"
-    fi
-}
-
-function check_symbols_path() {
-    case $waldo_build_suffix in
-        app)
-            if [[ -z $waldo_symbols_path && $waldo_include_symbols == true ]]; then
-                waldo_symbols_path=$(find_symbols_path)
-            fi
-            ;;
-        ipa) ;;
-        *) waldo_symbols_path="" ;; # not applicable
-    esac
-
-    [[ -n $waldo_symbols_path ]] || return 0
-
-    waldo_symbols_path=$(abs_path "$waldo_symbols_path")
-    waldo_symbols_suffix=${waldo_symbols_path##*.}
-
-    case $waldo_symbols_suffix in
-        dSYM|xcarchive|zip) ;;  # OK
-        *)                  fail "File extension of symbols at ‘${waldo_symbols_path}’ is not recognized" ;;
-    esac
-}
-
-function check_symbols_status() {
-    local _response=$1
-
-    local _status_regex='"status":([0-9]+)'
-
-    if [[ $_response =~ $_status_regex ]]; then
-        local _status=${BASH_REMATCH[1]}
-
-        if (( $_status == 401 )); then
-            fail "Upload token is invalid or missing!"
-        elif (( $_status < 200 || $_status > 299 )); then
-            fail "Unable to upload symbols to Waldo, HTTP status: $_status"
-        fi
-    fi
-}
-
-function check_upload_token() {
-    [[ -n $waldo_upload_token ]] || waldo_upload_token=${WALDO_UPLOAD_TOKEN:-}
-    [[ -n $waldo_upload_token ]] || fail_usage "Missing required option: ‘--upload_token’"
-}
-
-function check_variant_name() {
-    [[ -n $waldo_variant_name ]] || waldo_variant_name=${WALDO_VARIANT_NAME:-}
-}
-
-function convert_sha() {
-    local _full_sha=$1
-    local _full_name=$(git name-rev --refs='heads/*' --name-only "$_full_sha")
-    local _abbr_sha=${_full_sha:0:7}
-    local _abbr_name=$_full_name
-    local _prefix="remotes/origin/"
-
-    if [[ ${_full_name:0:${#_prefix}} == $_prefix ]]; then
-        _abbr_name=${_full_name#$_prefix}
-    else
-        _abbr_name="local:${_full_name}"
-    fi
-
-    echo "${_abbr_sha}-${_abbr_name}"
-}
-
-function convert_shas() {
-    local _list=
-
-    while (( $# )); do
-        local _item=$(convert_sha "$1")
-
-        _list+=",\"${_item}\""
-
-        shift
-    done
-
-    echo ${_list#?}
-}
-
-function create_build_payload() {
-    local _parent_path=$(dirname "$waldo_build_path")
-    local _build_name=$(basename "$waldo_build_path")
-
-    case $waldo_build_suffix in
-        app)
-            ([[ -d $waldo_build_path && -r $waldo_build_path ]])  \
-                || fail "Unable to read build at ‘${waldo_build_path}’"
-
-            if [[ -z $(which zip) ]]; then
-                fail "No ‘zip’ command found"
-            fi
-
-            waldo_build_payload_path="$waldo_working_path"/"$_build_name".zip
-
-            (cd "$_parent_path" &>/dev/null && zip -qry "$waldo_build_payload_path" "$_build_name") || return
-            ;;
-
-        *)
-            ([[ -f $waldo_build_path && -r $waldo_build_path ]])  \
-                || fail "Unable to read build at ‘${waldo_build_path}’"
-
-            waldo_build_payload_path=$waldo_build_path
-            ;;
-    esac
-}
-
-function create_symbols_payload() {
-    [[ -n $waldo_symbols_path ]] || return 0
-
-    local _parent_path=$(dirname "$waldo_symbols_path")
-    local _symbols_name=$(basename "$waldo_symbols_path")
-
-    case $waldo_symbols_suffix in
-        dSYM)
-            ([[ -d $waldo_symbols_path && -r $waldo_symbols_path ]])  \
-                || fail "Unable to read symbols at ‘${waldo_symbols_path}’"
-
-            if [[ -z $(which zip) ]]; then
-                fail "No ‘zip’ command found"
-            fi
-
-            waldo_symbols_payload_path="$waldo_working_path"/"$_symbols_name".zip
-
-            (cd "$_parent_path" &>/dev/null && zip -qry "$waldo_symbols_payload_path" "$_symbols_name") || return
-            ;;
-
-        xcarchive)
-            ([[ -d $waldo_symbols_path && -r $waldo_symbols_path ]])  \
-                || fail "Unable to read symbols at ‘${waldo_symbols_path}’"
-
-            if [[ -z $(which zip) ]]; then
-                fail "No ‘zip’ command found"
-            fi
-
-            local _tmp_symbols_path="$waldo_working_path"/"$_symbols_name"
-
-            mkdir -p "$_tmp_symbols_path"
-
-            cp -r "$waldo_symbols_path"/BCSymbolMaps "$_tmp_symbols_path"
-            cp -r "$waldo_symbols_path"/dSYMs "$_tmp_symbols_path"
-
-            waldo_symbols_payload_path="$_tmp_symbols_path".zip
-
-            (cd "$waldo_working_path" &>/dev/null && zip -qry "$waldo_symbols_payload_path" "$_symbols_name") || return
-            ;;
-
-        *)
-            ([[ -f $waldo_symbols_path && -r $waldo_symbols_path ]])  \
-                || fail "Unable to read symbols at ‘${waldo_symbols_path}’"
-
-            waldo_symbols_payload_path=$waldo_symbols_path
-            ;;
-    esac
-}
-
-function create_working_path() {
-    waldo_working_path=/tmp/WaldoCLI-$$
-
-    rm -rf "$waldo_working_path"
-    mkdir -p "$waldo_working_path"
-}
-
-function curl_upload_build() {
-    local _output_path="$1"
-    local _authorization=$(get_authorization)
-    local _content_type=$(get_build_content_type)
-    local _user_agent=$(get_user_agent)
-    local _url=$(make_build_url)
-
-    curl $waldo_extra_args                          \
-        --data-binary @"$waldo_build_payload_path"  \
-        --header "Authorization: $_authorization"   \
-        --header "Content-Type: $_content_type"     \
-        --header "User-Agent: $_user_agent"         \
-        --output "$_output_path"                    \
-        "$_url"
-
-    local _curl_status=$?
-
-    if (( $_curl_status != 0 )); then
-        fail "Unable to upload build to Waldo, curl error: ${_curl_status}, url: ${_url}"
-    fi
-}
-
-function curl_upload_error() {
-    local _message=$(json_escape "$1")
-    local _ci=$(get_ci)
-    local _authorization=$(get_authorization)
-    local _content_type=$(get_error_content_type)
-    local _user_agent=$(get_user_agent)
-    local _url=$(make_error_url)
-
-    curl --silent                                                   \
-        --data "{\"message\":\"${_message}\",\"ci\":\"${_ci}\"}"    \
-        --header "Authorization: $_authorization"                   \
-        --header "Content-Type: $_content_type"                     \
-        --header "User-Agent: $_user_agent"                         \
-        "$_url" &>/dev/null
-}
-
-function curl_upload_symbols() {
-    local _output_path="$1"
-    local _authorization=$(get_authorization)
-    local _content_type=$(get_symbols_content_type)
-    local _user_agent=$(get_user_agent)
-    local _url=$(make_symbols_url)
-
-    curl $waldo_extra_args                              \
-        --data-binary @"$waldo_symbols_payload_path"    \
-        --header "Authorization: $_authorization"       \
-        --header "Content-Type: $_content_type"         \
-        --header "User-Agent: $_user_agent"             \
-        --output "$_output_path"                        \
-        "$_url"
-
-    local _curl_status=$?
-
-    if (( $_curl_status != 0 )); then
-        fail "Unable to upload symbols to Waldo, curl error: ${_curl_status}, url: ${_url}"
-    fi
-}
-
-function delete_working_path() {
-    if [[ -n $waldo_working_path ]]; then
-        rm -rf "$waldo_working_path"
-    fi
-}
-
-function display_summary() {
-    echo ""
-    echo "Build path:   $(summarize "$waldo_build_path")"
-    echo "Symbols path: $(summarize "$waldo_symbols_path")"
-    echo "Variant name: $(summarize "$waldo_variant_name")"
-    echo "Upload token: $(summarize_secure "$waldo_upload_token")"
-    echo ""
-
-    if [[ $waldo_extra_args == "--verbose" ]]; then
-        echo "Build payload path:   $(summarize "$waldo_build_payload_path")"
-        echo "Symbols payload path: $(summarize "$waldo_symbols_payload_path")"
-        echo ""
-    fi
-}
-
-function display_usage() {
-    cat <<EOF
-
-OVERVIEW: Upload build to Waldo
-
-USAGE: waldo [options] <build-path> [<symbols-path>]
-
-OPTIONS:
-
-  --help                  Display available options
-  --include_symbols       Include symbols with the build upload
-  --upload_token <value>  Waldo upload token (overrides WALDO_UPLOAD_TOKEN)
-  --variant_name <value>  Waldo variant name (overrides WALDO_VARIANT_NAME)
-  --verbose               Display extra verbiage
-EOF
-}
-
-function display_version() {
-    waldo_platform=$(get_platform)
-
-    echo "Waldo CLI $waldo_cli_version ($waldo_platform)"
-}
-
-function fail() {
-    local _message="waldo: $1"
-
-    if [[ -n $waldo_upload_token ]]; then
-        curl_upload_error "$1"
-
-        local _curl_status=$?
-
-        if (( $_curl_status == 0)); then
-            _message+=" -- Waldo team has been informed"
-        fi
-    fi
-
-    echo ""                 # flush stdout
-    echo "$_message" 1>&2
-    exit 1
-}
-
-function fail_usage() {
-    [[ -z $waldo_upload_token ]] || curl_upload_error "$1"
-
-    echo ""                 # flush stdout
-    echo "waldo: $1" 1>&2
-    display_usage
-    exit 1
-}
-
-function find_symbols_path() {
-    if [[ -e ${waldo_build_path}.dSYM.zip ]]; then
-        echo "${waldo_build_path}.dSYM.zip"
-    elif [[ -e ${waldo_build_path}.dSYM ]]; then
-        echo "${waldo_build_path}.dSYM"
-    fi
-}
-
-function get_authorization() {
-    echo "Upload-Token $waldo_upload_token"
-}
-
-function get_build_content_type() {
-    case $waldo_build_suffix in
-        app) echo "application/zip" ;;
-        *)   echo "application/octet-stream" ;;
-    esac
-}
-
-function get_ci() {
-    if [[ -n ${APPCENTER_BUILD_ID:-} ]]; then
-        echo "App Center"
-    elif [[ ${BITRISE_IO:-false} == true ]]; then
-        echo "Bitrise"
-    elif [[ -n ${BUDDYBUILD_BUILD_ID:-} ]]; then
-        echo "buddybuild"
-    elif [[ ${CIRCLECI:-false} == true ]]; then
-        echo "CircleCI"
-    elif [[ ${GITHUB_ACTIONS:-false} == true ]]; then
-        echo "GitHub Actions"
-    elif [[ ${TRAVIS:-false} == true ]]; then
-        echo "Travis CI"
-    else
-        echo "CLI"
-    fi
-}
-
-function get_error_content_type() {
-    echo "application/json"
-}
-
-function get_history() {
-    local _shas=$(git log --format='%H' --skip=$(get_skip_count) -50)
-    local _history=$(convert_shas $_shas)
-
-    echo "[${_history}]" | websafe_base64_encode
-}
-
-function get_platform() {
-    local _os_name=$(uname -s)
-
-    case $_os_name in
-        Darwin) echo "macOS" ;;
-        *)      echo "$_os_name" ;;
-    esac
-}
-
-function get_skip_count() {
-    if [[ ${GITHUB_ACTIONS:-false} == true && ${GITHUB_EVENT_NAME:-} == "pull_request" ]]; then
-        echo "1"
-    else
-        echo "0"
-    fi
-}
-
-function get_symbols_content_type() {
-    echo "application/zip"
-}
-
-function get_user_agent() {
-    if [[ -n $waldo_user_agent_override ]]; then
-        echo "$waldo_user_agent_override"
-    else
-        echo "Waldo $(get_ci)/${waldo_build_flavor} v${waldo_cli_version}"
-    fi
-}
-
-function json_escape() {
-    local _result=${1//\\/\\\\} # \
-
-    _result=${_result//\//\\\/} # /
-    _result=${_result//\'/\\\'} # '
-    _result=${_result//\"/\\\"} # "
-
-    echo "$_result"
-}
-
-function make_build_url() {
-    local _query=
-
-    if [[ -n $waldo_history ]]; then
-        _query+="&history=$waldo_history"
-    fi
-
-    if [[ -n $waldo_history_error ]]; then
-        _query+="&historyError=$waldo_history_error"
-    fi
-
-    if [[ -n $waldo_variant_name ]]; then
-        _query+="&variantName=$waldo_variant_name"
-    fi
-
-    if [[ -n $_query ]]; then
-        echo "${waldo_api_build_endpoint}?${_query:1}"
-    else
-        echo "${waldo_api_build_endpoint}"
-    fi
-}
-
-function make_error_url() {
-    echo "${waldo_api_error_endpoint}"
-}
-
-function make_symbols_url() {
-    echo "${waldo_api_symbols_endpoint/__ID__/$waldo_build_upload_id}"
-}
-
-function summarize() {
-    local _value=$1
-
-    if [[ -n $_value ]]; then
-        echo "‘${_value}’"
-    else
-        echo "(none)"
-    fi
-}
-
-function summarize_secure() {
-    local _value=$1
-
-    if [[ $waldo_extra_args != "--verbose" ]]; then
-        local _prefix=${_value:0:6}
-        local _suffix_len=$(( ${#_value} - ${#_prefix} ))
-        local _secure='********************************'
-
-        _value="${_prefix}${_secure:0:$_suffix_len}"
-    fi
-
-    summarize "$_value"
-}
-
-function upload_build() {
-    local _build_name=$(basename "$waldo_build_path")
-
-    local _response_path=$waldo_working_path/build_response.json
-
-    echo "Uploading build to Waldo"
-
-    [[ $waldo_extra_args == "--verbose" ]] && echo ""
-
-    curl_upload_build "$_response_path"
-
-    local _curl_status=$?
-    local _response=$(cat "$_response_path" 2>/dev/null)
-
-    if [[ $waldo_extra_args == "--verbose" ]]; then
-        echo "$_response"
-        echo ""
-    fi
-
-    check_build_status "$_response"
-
-    if (( $_curl_status == 0 )); then
-        echo "Build ‘${_build_name}’ successfully uploaded to Waldo!"
-    fi
-}
-
-function upload_symbols() {
-    [[ -n $waldo_symbols_path ]] || return 0
-
-    local _symbols_name=$(basename "$waldo_symbols_path")
-
-    local _response_path=$waldo_working_path/symbols_response.json
-
-    echo "Uploading symbols to Waldo"
-
-    [[ $waldo_extra_args == "--verbose" ]] && echo ""
-
-    curl_upload_symbols "$_response_path"
-
-    local _curl_status=$?
-    local _response=$(cat "$_response_path" 2>/dev/null)
-
-    if [[ $waldo_extra_args == "--verbose" ]]; then
-        echo "$_response"
-        echo ""
-    fi
-
-    check_symbols_status "$_response"
-
-    if (( $_curl_status == 0 )); then
-        echo "Symbols in ‘${_symbols_name}’ successfully uploaded to Waldo!"
-    fi
-}
-
-function websafe_base64_encode() {
-    base64 | tr -d '\n' | tr '/+' '_-' | sed 's/=/%3D/g'
-}
-
-display_version
-
-while (( $# )); do
-    case $1 in
-        --help)
-            display_usage
-            exit
-            ;;
-
-        --include_symbols)
-            waldo_include_symbols=true
-            ;;
-
-        --upload_token)
-            if (( $# < 2 )) || [[ -z $2 || ${2:0:1} == "-" ]]; then
-                fail_usage "Missing required value for option: ‘${1}’"
-            else
-                waldo_upload_token=$2
-                shift
-            fi
-            ;;
-
-        --variant_name)
-            if (( $# < 2 )) || [[ -z $2 || ${2:0:1} == "-" ]]; then
-                fail_usage "Missing required value for option: ‘${1}’"
-            else
-                waldo_variant_name=$2
-                shift
-            fi
-            ;;
-
-        --verbose)
-            waldo_extra_args="--verbose"
-            ;;
-
-        -*)
-            fail_usage "Unknown option: ‘${1}’"
-            ;;
-
-        *)
-            if [[ -z $waldo_build_path ]]; then
-                waldo_build_path=$1
-            elif [[ -z $waldo_symbols_path ]]; then
-                waldo_symbols_path=$1
-            else
-                fail_usage "Unknown argument: ‘${1}’"
-            fi
-            ;;
-    esac
-
-    shift
-done
-
-check_platform || exit
-check_build_path || exit
-check_symbols_path || exit
-check_history || exit
-check_upload_token || exit
-check_variant_name || exit
-
-create_working_path || exit
-
-create_build_payload || exit
-create_symbols_payload || exit
-
-display_summary
-
-upload_build || exit
-upload_symbols || exit
-
-delete_working_path # failure is OK
-
-exit