From dd09e2ee12aba7274cb034bcc8cccba32c1b4131 Mon Sep 17 00:00:00 2001 From: lpusok <7979773+lpusok@users.noreply.github.com> Date: Fri, 25 Jun 2021 14:12:13 +0200 Subject: [PATCH] Updated tool lookup paths for new SDK layout (#23) * Updated tool lookup with new SDK layout * Updated to go modules * Log emulator output on failure * Adding sleep after killing emulator in test * Removed time.Sleep --- .gitignore | 1 + Gopkg.lock | 50 --- Gopkg.toml | 15 - bitrise.yml | 4 + go.mod | 10 + go.sum | 50 +++ main.go | 145 ++++--- .../bitrise-io/go-android/sdk/sdk.go | 176 ++++++++ .../go-steputils/stepconf/stepconf.go | 36 +- .../bitrise-io/go-utils/command/command.go | 19 +- .../go-utils/errorutil/errorutil.go | 36 -- .../bitrise-io/go-utils/pathutil/glob.go | 13 + .../go-utils/pathutil/path_filter.go | 143 +++++++ .../bitrise-io/go-utils/pathutil/pathutil.go | 52 +++ .../go-utils/pathutil/sortable_path.go | 88 ++++ .../bitrise-io/go-utils/pkcs12/LICENSE | 28 -- .../hashicorp/go-version/CHANGELOG.md | 25 ++ .../github.com/hashicorp/go-version/LICENSE | 354 ++++++++++++++++ .../github.com/hashicorp/go-version/README.md | 66 +++ .../hashicorp/go-version/constraint.go | 204 +++++++++ vendor/github.com/hashicorp/go-version/go.mod | 1 + .../hashicorp/go-version/version.go | 392 ++++++++++++++++++ .../go-version/version_collection.go | 17 + vendor/modules.txt | 20 + 24 files changed, 1748 insertions(+), 197 deletions(-) delete mode 100644 Gopkg.lock delete mode 100644 Gopkg.toml create mode 100644 go.mod create mode 100644 go.sum create mode 100644 vendor/github.com/bitrise-io/go-android/sdk/sdk.go delete mode 100644 vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/glob.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go create mode 100644 vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go delete mode 100644 vendor/github.com/bitrise-io/go-utils/pkcs12/LICENSE create mode 100644 vendor/github.com/hashicorp/go-version/CHANGELOG.md create mode 100644 vendor/github.com/hashicorp/go-version/LICENSE create mode 100644 vendor/github.com/hashicorp/go-version/README.md create mode 100644 vendor/github.com/hashicorp/go-version/constraint.go create mode 100644 vendor/github.com/hashicorp/go-version/go.mod create mode 100644 vendor/github.com/hashicorp/go-version/version.go create mode 100644 vendor/github.com/hashicorp/go-version/version_collection.go create mode 100644 vendor/modules.txt diff --git a/.gitignore b/.gitignore index 84324f6..a1c6c6e 100755 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ +steps-avd-manager .bitrise* _tmp \ No newline at end of file diff --git a/Gopkg.lock b/Gopkg.lock deleted file mode 100644 index 84241a4..0000000 --- a/Gopkg.lock +++ /dev/null @@ -1,50 +0,0 @@ -# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. - - -[[projects]] - branch = "master" - digest = "1:8f5fdb79a7a38f6b7dafbc47f620322f384a0cb06858cb28df0e5635e5bb4df4" - name = "github.com/bitrise-io/go-steputils" - packages = [ - "stepconf", - "tools", - ] - pruneopts = "UT" - revision = "f540824d77dfd382ce84fd0ee0a9da2fba1cce0a" - -[[projects]] - branch = "master" - digest = "1:0c8282cb84562f0119ecabf1841a5a63c4ee815178bc2f1ae678e49b27551a25" - name = "github.com/bitrise-io/go-utils" - packages = [ - "colorstring", - "command", - "errorutil", - "log", - "parseutil", - "pathutil", - "pointers", - ] - pruneopts = "UT" - revision = "4502d1f33875a0f8d7d6b73ba877a312b836fe40" - -[[projects]] - branch = "master" - digest = "1:400e113a367b511b9b09ca642ee11d9885485a93838526d697033af334a2fdde" - name = "github.com/kballard/go-shellquote" - packages = ["."] - pruneopts = "UT" - revision = "95032a82bc518f77982ea72343cc1ade730072f0" - -[solve-meta] - analyzer-name = "dep" - analyzer-version = 1 - input-imports = [ - "github.com/bitrise-io/go-steputils/stepconf", - "github.com/bitrise-io/go-steputils/tools", - "github.com/bitrise-io/go-utils/command", - "github.com/bitrise-io/go-utils/log", - "github.com/kballard/go-shellquote", - ] - solver-name = "gps-cdcl" - solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml deleted file mode 100644 index 39c2048..0000000 --- a/Gopkg.toml +++ /dev/null @@ -1,15 +0,0 @@ -[[constraint]] - branch = "master" - name = "github.com/bitrise-io/go-steputils" - -[[constraint]] - branch = "master" - name = "github.com/bitrise-io/go-utils" - -[[constraint]] - branch = "master" - name = "github.com/kballard/go-shellquote" - -[prune] - go-tests = true - unused-packages = true diff --git a/bitrise.yml b/bitrise.yml index 30f2084..73032f9 100755 --- a/bitrise.yml +++ b/bitrise.yml @@ -116,6 +116,10 @@ workflows: #!/bin/bash set -x adb -s $BITRISE_EMULATOR_SERIAL emu kill + adb devices + # It takes a bit of time for the simulator to exit + sleep 5 + adb devices # ---------------------------------------------------------------- # --- workflows to Share this step into a Step Library diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..ead5ba8 --- /dev/null +++ b/go.mod @@ -0,0 +1,10 @@ +module github.com/bitrise-steplib/steps-avd-manager + +go 1.16 + +require ( + github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e + github.com/bitrise-io/go-steputils v0.0.0-20210514150206-5b6261447e77 + github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 + github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..c8b7ed2 --- /dev/null +++ b/go.sum @@ -0,0 +1,50 @@ +github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e h1:lkJnz+yXbIqFGpDTdRBBshqxeX0UCndJmEOp0yy2GRQ= +github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e/go.mod h1:gGXmY8hJ1x44AC98TIvZZvxP7o+hs4VI6wgmO4JMfEg= +github.com/bitrise-io/go-steputils v0.0.0-20210514150206-5b6261447e77 h1:+wd+ADdtJCRL9JEghE1RMbR4ywXBYNvIBelAW/UkWr8= +github.com/bitrise-io/go-steputils v0.0.0-20210514150206-5b6261447e77/go.mod h1:H0iZjgsAR5NA6pnlD/zKB6AbxEsskq55pwJ9klVmP8w= +github.com/bitrise-io/go-utils v0.0.0-20210507100250-37de47dfa6ce/go.mod h1:15EZZf02noI5nWFqXMZEoyb1CyqYRXTMz5Fyu4CWFzI= +github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 h1:kclxBfygfNK6kWUB+9xcsfPLBen8Us9gubhitfL/Z6c= +github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5/go.mod h1:DRx7oFuAqk0dbKpAKCqWl0TgrowfJUb/MqYPRscxJOQ= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ= +github.com/hashicorp/go-retryablehttp v0.6.6/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY= +github.com/hashicorp/go-version v1.3.0 h1:McDWVJIU/y+u1BRV06dPaLfLCaT7fUTJLp5r04x7iNw= +github.com/hashicorp/go-version v1.3.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200219091948-cb0a6d8edb6c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210511113859-b0526f3d8744/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210503060354-a79de5458b56/go.mod h1:tfny5GFUkzUvx4ps4ajbZsCe5lw1metzhBm9T3x7oIY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= +gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/main.go b/main.go index 5028457..3bbac83 100755 --- a/main.go +++ b/main.go @@ -2,6 +2,7 @@ package main import ( "bufio" + "bytes" "fmt" "os" "path/filepath" @@ -9,6 +10,7 @@ import ( "strings" "time" + "github.com/bitrise-io/go-android/sdk" "github.com/bitrise-io/go-steputils/stepconf" "github.com/bitrise-io/go-steputils/tools" "github.com/bitrise-io/go-utils/command" @@ -18,7 +20,8 @@ import ( // config ... type config struct { - AndroidHome string `env:"ANDROID_HOME,required"` + AndroidHome string `env:"ANDROID_HOME"` + AndroidSDKRoot string `env:"ANDROID_SDK_ROOT"` APILevel int `env:"api_level,required"` Tag string `env:"tag,opt[google_apis,google_apis_playstore,android-wear,android-tv,default]"` DeviceProfile string `env:"profile,required"` @@ -30,12 +33,15 @@ type config struct { } func runningDeviceInfos(androidHome string) (map[string]string, error) { - cmd := command.New(filepath.Join(androidHome, "platform-tools/adb"), "devices") + cmd := command.New(filepath.Join(androidHome, "platform-tools", "adb"), "devices") out, err := cmd.RunAndReturnTrimmedCombinedOutput() if err != nil { return map[string]string{}, fmt.Errorf("command failed, error: %s", err) } + log.Debugf("$ %s", cmd.PrintableCommandArgs()) + log.Debugf("%s", out) + // List of devices attached // emulator-5554 device deviceListItemPattern := `^(?Pemulator-\d*)[\s+](?P.*)` @@ -88,6 +94,17 @@ func currentlyStartedDeviceSerial(alreadyRunningDeviceInfos, currentlyRunningDev return "" } +func queryNewDeviceSerial(androidHome string, runningDevices map[string]string) (string, error) { + currentRunningDevices, err := runningDeviceInfos(androidHome) + if err != nil { + return "", fmt.Errorf("failed to check running devices: %s", err) + } + + serial := currentlyStartedDeviceSerial(runningDevices, currentRunningDevices) + + return serial, nil +} + type phase struct { name string command *command.Model @@ -102,15 +119,31 @@ func main() { stepconf.Print(cfg) fmt.Println() - runningDevices, err := runningDeviceInfos(cfg.AndroidHome) + // Initialize Android SDK + log.Printf("Initialize Android SDK") + androidSdk, err := sdk.NewDefaultModel(sdk.Environment{ + AndroidHome: cfg.AndroidHome, + AndroidSDKRoot: cfg.AndroidSDKRoot, + }) + if err != nil { + failf("Failed to initialize Android SDK: %s", err) + } + + androidHome := androidSdk.GetAndroidHome() + runningDevices, err := runningDeviceInfos(androidHome) if err != nil { failf("Failed to check running devices, error: %s", err) } + cmdlineToolsPath, err := androidSdk.CmdlineToolsPath() + if err != nil { + failf("Could not locate Android command-line tools: %v", err) + } + var ( - sdkManagerPath = filepath.Join(cfg.AndroidHome, "tools/bin/sdkmanager") - avdManagerPath = filepath.Join(cfg.AndroidHome, "tools/bin/avdmanager") - emulatorPath = filepath.Join(cfg.AndroidHome, "emulator/emulator") + sdkManagerPath = filepath.Join(cmdlineToolsPath, "sdkmanager") + avdManagerPath = filepath.Join(cmdlineToolsPath, "avdmanager") + emulatorPath = filepath.Join(androidHome, "emulator", "emulator") pkg = fmt.Sprintf("system-images;android-%d;%s;%s", cfg.APILevel, cfg.Tag, cfg.Abi) yes, no = strings.Repeat("yes\n", 20), strings.Repeat("no\n", 20) @@ -127,19 +160,19 @@ func main() { } for _, phase := range []phase{ - {"Update emulator", + {"Updating emulator", command.New(sdkManagerPath, "--verbose", "--channel="+cfg.EmulatorChannel, "emulator"). SetStdin(strings.NewReader(yes)), // hitting yes in case it waits for accepting license nil, }, - {"Update system-image packages", + {"Updating system-image packages", command.New(sdkManagerPath, "--verbose", pkg). SetStdin(strings.NewReader(yes)), // hitting yes in case it waits for accepting license nil, }, - {"Create device", + {"Creating device", command.New(avdManagerPath, append([]string{ "--verbose", "create", "avd", "--force", "--name", cfg.ID, @@ -150,25 +183,6 @@ func main() { SetStdin(strings.NewReader(no)), // hitting no in case it asks for creating hw profile nil, }, - - {"Start device", - command.New(emulatorPath, append([]string{ - "@" + cfg.ID, - "-verbose", - "-show-kernel", - "-no-audio", - "-no-window", - "-no-boot-anim", - "-netdelay", "none", - "-no-snapshot", - "-wipe-data", - "-gpu", "swiftshader_indirect"}, startCustomFlags...)...), - func(cmd *command.Model) func() (string, error) { // need to start the emlator as a detached process - return func() (string, error) { - return "", cmd.GetCmd().Start() - } - }, - }, } { log.Infof(phase.name) log.Donef("$ %s", phase.command.PrintableCommandArgs()) @@ -179,37 +193,70 @@ func main() { } if out, err := exec(); err != nil { - failf("Failed to run phase, error: %s, output: %s", err, out) + failf("Failed to run phase: %s, output: %s", err, out) } fmt.Println() } - deviceDetectionStarted := time.Now() - for true { - currentRunningDevices, err := runningDeviceInfos(cfg.AndroidHome) - if err != nil { - failf("Failed to check running devices, error: %s", err) - } - - serial := currentlyStartedDeviceSerial(runningDevices, currentRunningDevices) - - if serial != "" { - if err := tools.ExportEnvironmentWithEnvman("BITRISE_EMULATOR_SERIAL", serial); err != nil { - log.Warnf("Failed to export environment (BITRISE_EMULATOR_SERIAL), error: %s", err) + var output bytes.Buffer + deviceStartCmd := command.New(emulatorPath, append([]string{ + "@" + cfg.ID, + "-verbose", + "-show-kernel", + "-no-audio", + "-no-window", + "-no-boot-anim", + "-netdelay", "none", + "-no-snapshot", + "-wipe-data", + "-gpu", "swiftshader_indirect"}, startCustomFlags...)..., + ).SetStdout(&output).SetStderr(&output) + + log.Infof("Starting device") + log.Donef("$ %s", deviceStartCmd.PrintableCommandArgs()) + // start the emlator as a detached process + emulatorWaitCh := make(chan error, 1) + if err := deviceStartCmd.GetCmd().Start(); err != nil { + failf("Failed to run device start command: %v", err) + } + go func() { + emulatorWaitCh <- deviceStartCmd.GetCmd().Wait() + }() + + var serial string + const bootWaitTime = time.Duration(300) + timeout := time.NewTimer(bootWaitTime * time.Second) + deviceCheckTicker := time.NewTicker(5 * time.Second) + +waitLoop: + for { + select { + case err := <-emulatorWaitCh: + log.Warnf("Emulator log: %s", output) + if err != nil { + failf("Emulator exited unexpectedly: %v", err) } - log.Printf("- Device with serial: %s started", serial) - break - } - - bootWaitTime := time.Duration(300) - - if time.Now().After(deviceDetectionStarted.Add(bootWaitTime * time.Second)) { + failf("Emulator exited early, without error. A possible cause can be the emulator process having received a KILL signal.") + case <-timeout.C: + log.Warnf("Emulator log: %s", output) failf("Failed to boot emulator device within %d seconds.", bootWaitTime) + case <-deviceCheckTicker.C: + serial, err = queryNewDeviceSerial(androidHome, runningDevices) + if err != nil { + failf("Error: %s", err) + } else if serial != "" { + break waitLoop + } } + } + timeout.Stop() + deviceCheckTicker.Stop() - time.Sleep(5 * time.Second) + if err := tools.ExportEnvironmentWithEnvman("BITRISE_EMULATOR_SERIAL", serial); err != nil { + log.Warnf("Failed to export environment (BITRISE_EMULATOR_SERIAL), error: %s", err) } + log.Printf("- Device with serial: %s started", serial) log.Donef("- Done") } diff --git a/vendor/github.com/bitrise-io/go-android/sdk/sdk.go b/vendor/github.com/bitrise-io/go-android/sdk/sdk.go new file mode 100644 index 0000000..5698b88 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-android/sdk/sdk.go @@ -0,0 +1,176 @@ +package sdk + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/bitrise-io/go-utils/pathutil" + "github.com/hashicorp/go-version" +) + +// Model ... +type Model struct { + androidHome string +} + +// Environment is used to pass in environment variables used to locate Android SDK +type Environment struct { + AndroidHome string // ANDROID_HOME + AndroidSDKRoot string // ANDROID_SDK_ROOT +} + +// NewEnvironment gets needed environment variables +func NewEnvironment() *Environment { + return &Environment{ + AndroidHome: os.Getenv("ANDROID_HOME"), + AndroidSDKRoot: os.Getenv("ANDROID_SDK_ROOT"), + } +} + +// AndroidSdkInterface ... +type AndroidSdkInterface interface { + GetAndroidHome() string + CmdlineToolsPath() (string, error) +} + +// New creates a Model with a supplied Android SDK path +func New(androidHome string) (*Model, error) { + evaluatedSDKRoot, err := validateAndroidSDKRoot(androidHome) + if err != nil { + return nil, err + } + + return &Model{androidHome: evaluatedSDKRoot}, nil +} + +// NewDefaultModel locates Android SDK based on environement variables +func NewDefaultModel(envs Environment) (*Model, error) { + // https://developer.android.com/studio/command-line/variables#envar + // Sets the path to the SDK installation directory. + // ANDROID_HOME, which also points to the SDK installation directory, is deprecated. + // If you continue to use it, the following rules apply: + // If ANDROID_HOME is defined and contains a valid SDK installation, its value is used instead of the value in ANDROID_SDK_ROOT. + // If ANDROID_HOME is not defined, the value in ANDROID_SDK_ROOT is used. + var warnings []string + for _, SDKdir := range []string{envs.AndroidHome, envs.AndroidSDKRoot} { + if SDKdir == "" { + warnings = append(warnings, "environment variable is unset or empty") + continue + } + + evaluatedSDKRoot, err := validateAndroidSDKRoot(SDKdir) + if err != nil { + warnings = append(warnings, err.Error()) + continue + } + + return &Model{androidHome: evaluatedSDKRoot}, nil + } + + return nil, fmt.Errorf("could not locate Android SDK root directory: %s", warnings) +} + +func validateAndroidSDKRoot(androidSDKRoot string) (string, error) { + evaluatedSDKRoot, err := filepath.EvalSymlinks(androidSDKRoot) + if err != nil { + return "", err + } + + if exist, err := pathutil.IsDirExists(evaluatedSDKRoot); err != nil { + return "", err + } else if !exist { + return "", fmt.Errorf("(%s) is not a valid Android SDK root", evaluatedSDKRoot) + } + + return evaluatedSDKRoot, nil +} + +// GetAndroidHome ... +func (model *Model) GetAndroidHome() string { + return model.androidHome +} + +// LatestBuildToolsDir ... +func (model *Model) LatestBuildToolsDir() (string, error) { + buildTools := filepath.Join(model.androidHome, "build-tools") + pattern := filepath.Join(buildTools, "*") + + buildToolsDirs, err := filepath.Glob(pattern) + if err != nil { + return "", err + } + + var latestVersion *version.Version + for _, buildToolsDir := range buildToolsDirs { + versionStr := strings.TrimPrefix(buildToolsDir, buildTools+"/") + version, err := version.NewVersion(versionStr) + if err != nil { + continue + } + + if latestVersion == nil || version.GreaterThan(latestVersion) { + latestVersion = version + } + } + + if latestVersion == nil || latestVersion.String() == "" { + return "", errors.New("failed to find latest build-tools dir") + } + + return filepath.Join(buildTools, latestVersion.String()), nil +} + +// LatestBuildToolPath ... +func (model *Model) LatestBuildToolPath(name string) (string, error) { + buildToolsDir, err := model.LatestBuildToolsDir() + if err != nil { + return "", err + } + + pth := filepath.Join(buildToolsDir, name) + if exist, err := pathutil.IsPathExists(pth); err != nil { + return "", err + } else if !exist { + return "", fmt.Errorf("tool (%s) not found at: %s", name, buildToolsDir) + } + + return pth, nil +} + +// CmdlineToolsPath locates the command-line tools directory +func (model *Model) CmdlineToolsPath() (string, error) { + toolPaths := []string{ + filepath.Join(model.GetAndroidHome(), "cmdline-tools", "latest", "bin"), + filepath.Join(model.GetAndroidHome(), "cmdline-tools", "*", "bin"), + filepath.Join(model.GetAndroidHome(), "tools", "bin"), + filepath.Join(model.GetAndroidHome(), "tools"), // legacy + } + + var warnings []string + for _, dirPattern := range toolPaths { + matches, err := filepath.Glob(dirPattern) + if err != nil { + return "", fmt.Errorf("failed to locate Android command-line tools directory, invalid patterns specified (%s): %s", toolPaths, err) + } + + if len(matches) == 0 { + continue + } + + sdkmanagerPath := matches[0] + if exists, err := pathutil.IsDirExists(sdkmanagerPath); err != nil { + warnings = append(warnings, fmt.Sprintf("failed to validate path (%s): %v", sdkmanagerPath, err)) + continue + } else if !exists { + warnings = append(warnings, "path (%s) does not exist or it is not a directory") + continue + } + + return sdkmanagerPath, nil + } + + return "", fmt.Errorf("failed to locate Android command-line tools directory on paths (%s), warnings: %s", toolPaths, warnings) +} diff --git a/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go index 027095b..9f7654a 100644 --- a/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go +++ b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go @@ -28,6 +28,7 @@ const rangeMaximumGroupName = "max" const rangeMinBracketGroupName = "minbr" const rangeMaxBracketGroupName = "maxbr" const rangeRegex = `range(?P<` + rangeMinBracketGroupName + `>\[|\])(?P<` + rangeMinimumGroupName + `>.*?)\.\.(?P<` + rangeMaximumGroupName + `>.*?)(?P<` + rangeMaxBracketGroupName + `>\[|\])` +const multilineConstraintName = "multiline" // Error implements builtin errors.Error. func (e *ParseError) Error() string { @@ -56,7 +57,19 @@ func (s Secret) String() string { // Print the name of the struct with Title case in blue color with followed by a newline, // then print all fields formatted as '- field name: field value` separated by newline. func Print(config interface{}) { - fmt.Printf(toString(config)) + fmt.Print(toString(config)) +} + +func valueString(v reflect.Value) string { + if v.Kind() != reflect.Ptr { + return fmt.Sprintf("%v", v.Interface()) + } + + if !v.IsNil() { + return fmt.Sprintf("%v", v.Elem().Interface()) + } + + return "" } // returns the name of the struct with Title case in blue color followed by a newline, @@ -73,9 +86,9 @@ func toString(config interface{}) string { t = t.Elem() } - str := fmt.Sprintf(colorstring.Bluef("%s:\n", strings.Title(t.Name()))) + str := fmt.Sprint(colorstring.Bluef("%s:\n", strings.Title(t.Name()))) for i := 0; i < t.NumField(); i++ { - str += fmt.Sprintf("- %s: %v\n", t.Field(i).Name, v.Field(i).Interface()) + str += fmt.Sprintf("- %s: %s\n", t.Field(i).Name, valueString(v.Field(i))) } return str @@ -137,6 +150,14 @@ func setField(field reflect.Value, value, constraint string) error { return nil } + if field.Kind() == reflect.Ptr { + // If field is a pointer type, then set its value to be a pointer to a new zero value, matching field underlying type. + var dePtrdType = field.Type().Elem() // get the type field can point to + var newPtrType = reflect.New(dePtrdType) // create new ptr address for type with non-nil zero value + field.Set(newPtrType) // assign value to pointer + field = field.Elem() + } + switch field.Kind() { case reflect.String: field.SetString(value) @@ -153,13 +174,18 @@ func setField(field reflect.Value, value, constraint string) error { } field.SetInt(n) case reflect.Float64: + value = strings.TrimSpace(value) f, err := strconv.ParseFloat(value, 64) if err != nil { return errors.New("can't convert to float") } field.SetFloat(f) case reflect.Slice: - field.Set(reflect.ValueOf(strings.Split(value, "|"))) + if constraint == multilineConstraintName { + field.Set(reflect.ValueOf(strings.Split(value, "\n"))) + } else { + field.Set(reflect.ValueOf(strings.Split(value, "|"))) + } default: return fmt.Errorf("type is not supported (%s)", field.Kind()) } @@ -188,6 +214,8 @@ func validateConstraint(value, constraint string) error { if err := ValidateRangeFields(value, constraint); err != nil { return err } + case multilineConstraintName: + break default: return fmt.Errorf("invalid constraint (%s)", constraint) } diff --git a/vendor/github.com/bitrise-io/go-utils/command/command.go b/vendor/github.com/bitrise-io/go-utils/command/command.go index 4cd005a..c068490 100644 --- a/vendor/github.com/bitrise-io/go-utils/command/command.go +++ b/vendor/github.com/bitrise-io/go-utils/command/command.go @@ -2,14 +2,11 @@ package command import ( "errors" - "fmt" "io" "os" "os/exec" "strconv" "strings" - - "github.com/bitrise-io/go-utils/errorutil" ) // ---------- @@ -139,18 +136,10 @@ func PrintableCommandArgs(isQuoteFirst bool, fullCommandArgs []string) string { } // RunCmdAndReturnExitCode ... -func RunCmdAndReturnExitCode(cmd *exec.Cmd) (int, error) { - err := cmd.Run() - if err != nil { - exitCode, castErr := errorutil.CmdExitCodeFromError(err) - if castErr != nil { - return 1, fmt.Errorf("failed get exit code from error: %s, error: %s", err, castErr) - } - - return exitCode, err - } - - return 0, nil +func RunCmdAndReturnExitCode(cmd *exec.Cmd) (exitCode int, err error) { + err = cmd.Run() + exitCode = cmd.ProcessState.ExitCode() + return } // RunCmdAndReturnTrimmedOutput ... diff --git a/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go b/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go deleted file mode 100644 index 1128416..0000000 --- a/vendor/github.com/bitrise-io/go-utils/errorutil/errorutil.go +++ /dev/null @@ -1,36 +0,0 @@ -package errorutil - -import ( - "errors" - "os/exec" - "regexp" - "syscall" -) - -// IsExitStatusError ... -func IsExitStatusError(err error) bool { - return IsExitStatusErrorStr(err.Error()) -} - -// IsExitStatusErrorStr ... -func IsExitStatusErrorStr(errString string) bool { - // example exit status error string: exit status 1 - var rex = regexp.MustCompile(`^exit status [0-9]{1,3}$`) - return rex.MatchString(errString) -} - -// CmdExitCodeFromError ... -func CmdExitCodeFromError(err error) (int, error) { - cmdExitCode := 0 - if err != nil { - if exitError, ok := err.(*exec.ExitError); ok { - waitStatus, ok := exitError.Sys().(syscall.WaitStatus) - if !ok { - return 1, errors.New("Failed to cast exit status") - } - cmdExitCode = waitStatus.ExitStatus() - } - return cmdExitCode, nil - } - return 0, nil -} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go b/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go new file mode 100644 index 0000000..232dd51 --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/glob.go @@ -0,0 +1,13 @@ +package pathutil + +// EscapeGlobPath escapes a partial path, determined at runtime, used as a parameter for filepath.Glob +func EscapeGlobPath(path string) string { + var escaped string + for _, ch := range path { + if ch == '[' || ch == ']' || ch == '-' || ch == '*' || ch == '?' || ch == '\\' { + escaped += "\\" + } + escaped += string(ch) + } + return escaped +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go b/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go new file mode 100644 index 0000000..0bfd0fc --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/path_filter.go @@ -0,0 +1,143 @@ +package pathutil + +import ( + "errors" + "io/ioutil" + "os" + "path/filepath" + "regexp" + "strings" +) + +// FilterPaths ... +func FilterPaths(fileList []string, filters ...FilterFunc) ([]string, error) { + var filtered []string + + for _, pth := range fileList { + allowed := true + for _, filter := range filters { + if allows, err := filter(pth); err != nil { + return []string{}, err + } else if !allows { + allowed = false + break + } + } + if allowed { + filtered = append(filtered, pth) + } + } + + return filtered, nil +} + +// FilterFunc ... +type FilterFunc func(string) (bool, error) + +// BaseFilter ... +func BaseFilter(base string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + b := filepath.Base(pth) + return allowed == strings.EqualFold(base, b), nil + } +} + +// ExtensionFilter ... +func ExtensionFilter(ext string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + e := filepath.Ext(pth) + return allowed == strings.EqualFold(ext, e), nil + } +} + +// RegexpFilter ... +func RegexpFilter(pattern string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + re := regexp.MustCompile(pattern) + found := re.FindString(pth) != "" + return allowed == found, nil + } +} + +// ComponentFilter ... +func ComponentFilter(component string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + found := false + pathComponents := strings.Split(pth, string(filepath.Separator)) + for _, c := range pathComponents { + if c == component { + found = true + } + } + return allowed == found, nil + } +} + +// ComponentWithExtensionFilter ... +func ComponentWithExtensionFilter(ext string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + found := false + pathComponents := strings.Split(pth, string(filepath.Separator)) + for _, c := range pathComponents { + e := filepath.Ext(c) + if e == ext { + found = true + } + } + return allowed == found, nil + } +} + +// IsDirectoryFilter ... +func IsDirectoryFilter(allowed bool) FilterFunc { + return func(pth string) (bool, error) { + fileInf, err := os.Lstat(pth) + if err != nil { + return false, err + } + if fileInf == nil { + return false, errors.New("no file info available") + } + return allowed == fileInf.IsDir(), nil + } +} + +// InDirectoryFilter ... +func InDirectoryFilter(dir string, allowed bool) FilterFunc { + return func(pth string) (bool, error) { + in := filepath.Dir(pth) == dir + return allowed == in, nil + } +} + +// DirectoryContainsFileFilter returns a FilterFunc that checks if a directory contains a file +func DirectoryContainsFileFilter(fileName string) FilterFunc { + return func(pth string) (bool, error) { + isDir, err := IsDirectoryFilter(true)(pth) + if err != nil { + return false, err + } + if !isDir { + return false, nil + } + + absPath := filepath.Join(pth, fileName) + if _, err := os.Lstat(absPath); err != nil { + if !os.IsNotExist(err) { + return false, err + } + return false, nil + } + return true, nil + } +} + +// FileContainsFilter ... +func FileContainsFilter(pth, str string) (bool, error) { + bytes, err := ioutil.ReadFile(pth) + if err != nil { + return false, err + } + + return strings.Contains(string(bytes), str), nil +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go b/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go index a88ff5f..db577e3 100644 --- a/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/pathutil.go @@ -184,3 +184,55 @@ func NormalizedOSTempDirPath(tmpDirNamePrefix string) (retPth string, err error) func GetFileName(path string) string { return strings.TrimSuffix(filepath.Base(path), filepath.Ext(path)) } + +// ListPathInDirSortedByComponents ... +func ListPathInDirSortedByComponents(searchDir string, relPath bool) ([]string, error) { + searchDir, err := filepath.Abs(searchDir) + if err != nil { + return []string{}, err + } + + var fileList []string + + if err := filepath.Walk(searchDir, func(path string, _ os.FileInfo, walkErr error) error { + if walkErr != nil { + return walkErr + } + + if relPath { + rel, err := filepath.Rel(searchDir, path) + if err != nil { + return err + } + path = rel + } + + fileList = append(fileList, path) + + return nil + }); err != nil { + return []string{}, err + } + return SortPathsByComponents(fileList) +} + +// ListEntries filters contents of a directory using the provided filters +func ListEntries(dir string, filters ...FilterFunc) ([]string, error) { + absDir, err := filepath.Abs(dir) + if err != nil { + return []string{}, err + } + + entries, err := ioutil.ReadDir(absDir) + if err != nil { + return []string{}, err + } + + var paths []string + for _, entry := range entries { + pth := filepath.Join(absDir, entry.Name()) + paths = append(paths, pth) + } + + return FilterPaths(paths, filters...) +} diff --git a/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go b/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go new file mode 100644 index 0000000..4bed6bf --- /dev/null +++ b/vendor/github.com/bitrise-io/go-utils/pathutil/sortable_path.go @@ -0,0 +1,88 @@ +package pathutil + +import ( + "os" + "path/filepath" + "sort" + "strings" +) + +// SortablePath ... +type SortablePath struct { + Pth string + AbsPth string + Components []string +} + +// NewSortablePath ... +func NewSortablePath(pth string) (SortablePath, error) { + absPth, err := AbsPath(pth) + if err != nil { + return SortablePath{}, err + } + + components := strings.Split(absPth, string(os.PathSeparator)) + fixedComponents := []string{} + for _, comp := range components { + if comp != "" { + fixedComponents = append(fixedComponents, comp) + } + } + + return SortablePath{ + Pth: pth, + AbsPth: absPth, + Components: fixedComponents, + }, nil +} + +// BySortablePathComponents .. +type BySortablePathComponents []SortablePath + +func (s BySortablePathComponents) Len() int { + return len(s) +} +func (s BySortablePathComponents) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} +func (s BySortablePathComponents) Less(i, j int) bool { + path1 := s[i] + path2 := s[j] + + d1 := len(path1.Components) + d2 := len(path2.Components) + + if d1 < d2 { + return true + } else if d1 > d2 { + return false + } + + // if same component size, + // do alphabetic sort based on the last component + base1 := filepath.Base(path1.AbsPth) + base2 := filepath.Base(path2.AbsPth) + + return base1 < base2 +} + +// SortPathsByComponents ... +func SortPathsByComponents(paths []string) ([]string, error) { + sortableFiles := []SortablePath{} + for _, pth := range paths { + sortable, err := NewSortablePath(pth) + if err != nil { + return []string{}, err + } + sortableFiles = append(sortableFiles, sortable) + } + + sort.Sort(BySortablePathComponents(sortableFiles)) + + sortedFiles := []string{} + for _, pth := range sortableFiles { + sortedFiles = append(sortedFiles, pth.Pth) + } + + return sortedFiles, nil +} diff --git a/vendor/github.com/bitrise-io/go-utils/pkcs12/LICENSE b/vendor/github.com/bitrise-io/go-utils/pkcs12/LICENSE deleted file mode 100644 index bcecd3d..0000000 --- a/vendor/github.com/bitrise-io/go-utils/pkcs12/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright (c) 2015, 2018, 2019 Opsmate, Inc. All rights reserved. -Copyright (c) 2009 The Go Authors. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/hashicorp/go-version/CHANGELOG.md b/vendor/github.com/hashicorp/go-version/CHANGELOG.md new file mode 100644 index 0000000..dbae7f7 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/CHANGELOG.md @@ -0,0 +1,25 @@ +# 1.3.0 (March 31, 2021) + +Please note that CHANGELOG.md does not exist in the source code prior to this release. + +FEATURES: + - Add `Core` function to return a version without prerelease or metadata ([#85](https://github.com/hashicorp/go-version/pull/85)) + +# 1.2.1 (June 17, 2020) + +BUG FIXES: + - Prevent `Version.Equal` method from panicking on `nil` encounter ([#73](https://github.com/hashicorp/go-version/pull/73)) + +# 1.2.0 (April 23, 2019) + +FEATURES: + - Add `GreaterThanOrEqual` and `LessThanOrEqual` helper methods ([#53](https://github.com/hashicorp/go-version/pull/53)) + +# 1.1.0 (Jan 07, 2019) + +FEATURES: + - Add `NewSemver` constructor ([#45](https://github.com/hashicorp/go-version/pull/45)) + +# 1.0.0 (August 24, 2018) + +Initial release. diff --git a/vendor/github.com/hashicorp/go-version/LICENSE b/vendor/github.com/hashicorp/go-version/LICENSE new file mode 100644 index 0000000..c33dcc7 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/LICENSE @@ -0,0 +1,354 @@ +Mozilla Public License, version 2.0 + +1. Definitions + +1.1. “Contributor” + + means each individual or legal entity that creates, contributes to the + creation of, or owns Covered Software. + +1.2. “Contributor Version” + + means the combination of the Contributions of others (if any) used by a + Contributor and that particular Contributor’s Contribution. + +1.3. “Contribution” + + means Covered Software of a particular Contributor. + +1.4. “Covered Software” + + means Source Code Form to which the initial Contributor has attached the + notice in Exhibit A, the Executable Form of such Source Code Form, and + Modifications of such Source Code Form, in each case including portions + thereof. + +1.5. “Incompatible With Secondary Licenses” + means + + a. that the initial Contributor has attached the notice described in + Exhibit B to the Covered Software; or + + b. that the Covered Software was made available under the terms of version + 1.1 or earlier of the License, but not also under the terms of a + Secondary License. + +1.6. “Executable Form” + + means any form of the work other than Source Code Form. + +1.7. “Larger Work” + + means a work that combines Covered Software with other material, in a separate + file or files, that is not Covered Software. + +1.8. “License” + + means this document. + +1.9. “Licensable” + + means having the right to grant, to the maximum extent possible, whether at the + time of the initial grant or subsequently, any and all of the rights conveyed by + this License. + +1.10. “Modifications” + + means any of the following: + + a. any file in Source Code Form that results from an addition to, deletion + from, or modification of the contents of Covered Software; or + + b. any new file in Source Code Form that contains any Covered Software. + +1.11. “Patent Claims” of a Contributor + + means any patent claim(s), including without limitation, method, process, + and apparatus claims, in any patent Licensable by such Contributor that + would be infringed, but for the grant of the License, by the making, + using, selling, offering for sale, having made, import, or transfer of + either its Contributions or its Contributor Version. + +1.12. “Secondary License” + + means either the GNU General Public License, Version 2.0, the GNU Lesser + General Public License, Version 2.1, the GNU Affero General Public + License, Version 3.0, or any later versions of those licenses. + +1.13. “Source Code Form” + + means the form of the work preferred for making modifications. + +1.14. “You” (or “Your”) + + means an individual or a legal entity exercising rights under this + License. For legal entities, “You” includes any entity that controls, is + controlled by, or is under common control with You. For purposes of this + definition, “control” means (a) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or + otherwise, or (b) ownership of more than fifty percent (50%) of the + outstanding shares or beneficial ownership of such entity. + + +2. License Grants and Conditions + +2.1. Grants + + Each Contributor hereby grants You a world-wide, royalty-free, + non-exclusive license: + + a. under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or as + part of a Larger Work; and + + b. under Patent Claims of such Contributor to make, use, sell, offer for + sale, have made, import, and otherwise transfer either its Contributions + or its Contributor Version. + +2.2. Effective Date + + The licenses granted in Section 2.1 with respect to any Contribution become + effective for each Contribution on the date the Contributor first distributes + such Contribution. + +2.3. Limitations on Grant Scope + + The licenses granted in this Section 2 are the only rights granted under this + License. No additional rights or licenses will be implied from the distribution + or licensing of Covered Software under this License. Notwithstanding Section + 2.1(b) above, no patent license is granted by a Contributor: + + a. for any code that a Contributor has removed from Covered Software; or + + b. for infringements caused by: (i) Your and any other third party’s + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + + c. under Patent Claims infringed by Covered Software in the absence of its + Contributions. + + This License does not grant any rights in the trademarks, service marks, or + logos of any Contributor (except as may be necessary to comply with the + notice requirements in Section 3.4). + +2.4. Subsequent Licenses + + No Contributor makes additional grants as a result of Your choice to + distribute the Covered Software under a subsequent version of this License + (see Section 10.2) or under the terms of a Secondary License (if permitted + under the terms of Section 3.3). + +2.5. Representation + + Each Contributor represents that the Contributor believes its Contributions + are its original creation(s) or it has sufficient rights to grant the + rights to its Contributions conveyed by this License. + +2.6. Fair Use + + This License is not intended to limit any rights You have under applicable + copyright doctrines of fair use, fair dealing, or other equivalents. + +2.7. Conditions + + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in + Section 2.1. + + +3. Responsibilities + +3.1. Distribution of Source Form + + All distribution of Covered Software in Source Code Form, including any + Modifications that You create or to which You contribute, must be under the + terms of this License. You must inform recipients that the Source Code Form + of the Covered Software is governed by the terms of this License, and how + they can obtain a copy of this License. You may not attempt to alter or + restrict the recipients’ rights in the Source Code Form. + +3.2. Distribution of Executable Form + + If You distribute Covered Software in Executable Form then: + + a. such Covered Software must also be made available in Source Code Form, + as described in Section 3.1, and You must inform recipients of the + Executable Form how they can obtain a copy of such Source Code Form by + reasonable means in a timely manner, at a charge no more than the cost + of distribution to the recipient; and + + b. You may distribute such Executable Form under the terms of this License, + or sublicense it under different terms, provided that the license for + the Executable Form does not attempt to limit or alter the recipients’ + rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + + You may create and distribute a Larger Work under terms of Your choice, + provided that You also comply with the requirements of this License for the + Covered Software. If the Larger Work is a combination of Covered Software + with a work governed by one or more Secondary Licenses, and the Covered + Software is not Incompatible With Secondary Licenses, this License permits + You to additionally distribute such Covered Software under the terms of + such Secondary License(s), so that the recipient of the Larger Work may, at + their option, further distribute the Covered Software under the terms of + either this License or such Secondary License(s). + +3.4. Notices + + You may not remove or alter the substance of any license notices (including + copyright notices, patent notices, disclaimers of warranty, or limitations + of liability) contained within the Source Code Form of the Covered + Software, except that You may alter any license notices to the extent + required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + + You may choose to offer, and to charge a fee for, warranty, support, + indemnity or liability obligations to one or more recipients of Covered + Software. However, You may do so only on Your own behalf, and not on behalf + of any Contributor. You must make it absolutely clear that any such + warranty, support, indemnity, or liability obligation is offered by You + alone, and You hereby agree to indemnify every Contributor for any + liability incurred by such Contributor as a result of warranty, support, + indemnity or liability terms You offer. You may include additional + disclaimers of warranty and limitations of liability specific to any + jurisdiction. + +4. Inability to Comply Due to Statute or Regulation + + If it is impossible for You to comply with any of the terms of this License + with respect to some or all of the Covered Software due to statute, judicial + order, or regulation then You must: (a) comply with the terms of this License + to the maximum extent possible; and (b) describe the limitations and the code + they affect. Such description must be placed in a text file included with all + distributions of the Covered Software under this License. Except to the + extent prohibited by statute or regulation, such description must be + sufficiently detailed for a recipient of ordinary skill to be able to + understand it. + +5. Termination + +5.1. The rights granted under this License will terminate automatically if You + fail to comply with any of its terms. However, if You become compliant, + then the rights granted under this License from a particular Contributor + are reinstated (a) provisionally, unless and until such Contributor + explicitly and finally terminates Your grants, and (b) on an ongoing basis, + if such Contributor fails to notify You of the non-compliance by some + reasonable means prior to 60 days after You have come back into compliance. + Moreover, Your grants from a particular Contributor are reinstated on an + ongoing basis if such Contributor notifies You of the non-compliance by + some reasonable means, this is the first time You have received notice of + non-compliance with this License from such Contributor, and You become + compliant prior to 30 days after Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent + infringement claim (excluding declaratory judgment actions, counter-claims, + and cross-claims) alleging that a Contributor Version directly or + indirectly infringes any patent, then the rights granted to You by any and + all Contributors for the Covered Software under Section 2.1 of this License + shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user + license agreements (excluding distributors and resellers) which have been + validly granted by You or Your distributors under this License prior to + termination shall survive termination. + +6. Disclaimer of Warranty + + Covered Software is provided under this License on an “as is” basis, without + warranty of any kind, either expressed, implied, or statutory, including, + without limitation, warranties that the Covered Software is free of defects, + merchantable, fit for a particular purpose or non-infringing. The entire + risk as to the quality and performance of the Covered Software is with You. + Should any Covered Software prove defective in any respect, You (not any + Contributor) assume the cost of any necessary servicing, repair, or + correction. This disclaimer of warranty constitutes an essential part of this + License. No use of any Covered Software is authorized under this License + except under this disclaimer. + +7. Limitation of Liability + + Under no circumstances and under no legal theory, whether tort (including + negligence), contract, or otherwise, shall any Contributor, or anyone who + distributes Covered Software as permitted above, be liable to You for any + direct, indirect, special, incidental, or consequential damages of any + character including, without limitation, damages for lost profits, loss of + goodwill, work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses, even if such party shall have been + informed of the possibility of such damages. This limitation of liability + shall not apply to liability for death or personal injury resulting from such + party’s negligence to the extent applicable law prohibits such limitation. + Some jurisdictions do not allow the exclusion or limitation of incidental or + consequential damages, so this exclusion and limitation may not apply to You. + +8. Litigation + + Any litigation relating to this License may be brought only in the courts of + a jurisdiction where the defendant maintains its principal place of business + and such litigation shall be governed by laws of that jurisdiction, without + reference to its conflict-of-law provisions. Nothing in this Section shall + prevent a party’s ability to bring cross-claims or counter-claims. + +9. Miscellaneous + + This License represents the complete agreement concerning the subject matter + hereof. If any provision of this License is held to be unenforceable, such + provision shall be reformed only to the extent necessary to make it + enforceable. Any law or regulation which provides that the language of a + contract shall be construed against the drafter shall not be used to construe + this License against a Contributor. + + +10. Versions of the License + +10.1. New Versions + + Mozilla Foundation is the license steward. Except as provided in Section + 10.3, no one other than the license steward has the right to modify or + publish new versions of this License. Each version will be given a + distinguishing version number. + +10.2. Effect of New Versions + + You may distribute the Covered Software under the terms of the version of + the License under which You originally received the Covered Software, or + under the terms of any subsequent version published by the license + steward. + +10.3. Modified Versions + + If you create software not governed by this License, and you want to + create a new license for such software, you may create and use a modified + version of this License if you rename the license and remove any + references to the name of the license steward (except to note that such + modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses + If You choose to distribute Source Code Form that is Incompatible With + Secondary Licenses under the terms of this version of the License, the + notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the + terms of the Mozilla Public License, v. + 2.0. If a copy of the MPL was not + distributed with this file, You can + obtain one at + http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular file, then +You may include the notice in a location (such as a LICENSE file in a relevant +directory) where a recipient would be likely to look for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - “Incompatible With Secondary Licenses” Notice + + This Source Code Form is “Incompatible + With Secondary Licenses”, as defined by + the Mozilla Public License, v. 2.0. + diff --git a/vendor/github.com/hashicorp/go-version/README.md b/vendor/github.com/hashicorp/go-version/README.md new file mode 100644 index 0000000..851a337 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/README.md @@ -0,0 +1,66 @@ +# Versioning Library for Go +[![Build Status](https://circleci.com/gh/hashicorp/go-version/tree/master.svg?style=svg)](https://circleci.com/gh/hashicorp/go-version/tree/master) +[![GoDoc](https://godoc.org/github.com/hashicorp/go-version?status.svg)](https://godoc.org/github.com/hashicorp/go-version) + +go-version is a library for parsing versions and version constraints, +and verifying versions against a set of constraints. go-version +can sort a collection of versions properly, handles prerelease/beta +versions, can increment versions, etc. + +Versions used with go-version must follow [SemVer](http://semver.org/). + +## Installation and Usage + +Package documentation can be found on +[GoDoc](http://godoc.org/github.com/hashicorp/go-version). + +Installation can be done with a normal `go get`: + +``` +$ go get github.com/hashicorp/go-version +``` + +#### Version Parsing and Comparison + +```go +v1, err := version.NewVersion("1.2") +v2, err := version.NewVersion("1.5+metadata") + +// Comparison example. There is also GreaterThan, Equal, and just +// a simple Compare that returns an int allowing easy >=, <=, etc. +if v1.LessThan(v2) { + fmt.Printf("%s is less than %s", v1, v2) +} +``` + +#### Version Constraints + +```go +v1, err := version.NewVersion("1.2") + +// Constraints example. +constraints, err := version.NewConstraint(">= 1.0, < 1.4") +if constraints.Check(v1) { + fmt.Printf("%s satisfies constraints %s", v1, constraints) +} +``` + +#### Version Sorting + +```go +versionsRaw := []string{"1.1", "0.7.1", "1.4-beta", "1.4", "2"} +versions := make([]*version.Version, len(versionsRaw)) +for i, raw := range versionsRaw { + v, _ := version.NewVersion(raw) + versions[i] = v +} + +// After this, the versions are properly sorted +sort.Sort(version.Collection(versions)) +``` + +## Issues and Contributing + +If you find an issue with this library, please report an issue. If you'd +like, we welcome any contributions. Fork this library and submit a pull +request. diff --git a/vendor/github.com/hashicorp/go-version/constraint.go b/vendor/github.com/hashicorp/go-version/constraint.go new file mode 100644 index 0000000..d055759 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/constraint.go @@ -0,0 +1,204 @@ +package version + +import ( + "fmt" + "reflect" + "regexp" + "strings" +) + +// Constraint represents a single constraint for a version, such as +// ">= 1.0". +type Constraint struct { + f constraintFunc + check *Version + original string +} + +// Constraints is a slice of constraints. We make a custom type so that +// we can add methods to it. +type Constraints []*Constraint + +type constraintFunc func(v, c *Version) bool + +var constraintOperators map[string]constraintFunc + +var constraintRegexp *regexp.Regexp + +func init() { + constraintOperators = map[string]constraintFunc{ + "": constraintEqual, + "=": constraintEqual, + "!=": constraintNotEqual, + ">": constraintGreaterThan, + "<": constraintLessThan, + ">=": constraintGreaterThanEqual, + "<=": constraintLessThanEqual, + "~>": constraintPessimistic, + } + + ops := make([]string, 0, len(constraintOperators)) + for k := range constraintOperators { + ops = append(ops, regexp.QuoteMeta(k)) + } + + constraintRegexp = regexp.MustCompile(fmt.Sprintf( + `^\s*(%s)\s*(%s)\s*$`, + strings.Join(ops, "|"), + VersionRegexpRaw)) +} + +// NewConstraint will parse one or more constraints from the given +// constraint string. The string must be a comma-separated list of +// constraints. +func NewConstraint(v string) (Constraints, error) { + vs := strings.Split(v, ",") + result := make([]*Constraint, len(vs)) + for i, single := range vs { + c, err := parseSingle(single) + if err != nil { + return nil, err + } + + result[i] = c + } + + return Constraints(result), nil +} + +// Check tests if a version satisfies all the constraints. +func (cs Constraints) Check(v *Version) bool { + for _, c := range cs { + if !c.Check(v) { + return false + } + } + + return true +} + +// Returns the string format of the constraints +func (cs Constraints) String() string { + csStr := make([]string, len(cs)) + for i, c := range cs { + csStr[i] = c.String() + } + + return strings.Join(csStr, ",") +} + +// Check tests if a constraint is validated by the given version. +func (c *Constraint) Check(v *Version) bool { + return c.f(v, c.check) +} + +func (c *Constraint) String() string { + return c.original +} + +func parseSingle(v string) (*Constraint, error) { + matches := constraintRegexp.FindStringSubmatch(v) + if matches == nil { + return nil, fmt.Errorf("Malformed constraint: %s", v) + } + + check, err := NewVersion(matches[2]) + if err != nil { + return nil, err + } + + return &Constraint{ + f: constraintOperators[matches[1]], + check: check, + original: v, + }, nil +} + +func prereleaseCheck(v, c *Version) bool { + switch vPre, cPre := v.Prerelease() != "", c.Prerelease() != ""; { + case cPre && vPre: + // A constraint with a pre-release can only match a pre-release version + // with the same base segments. + return reflect.DeepEqual(c.Segments64(), v.Segments64()) + + case !cPre && vPre: + // A constraint without a pre-release can only match a version without a + // pre-release. + return false + + case cPre && !vPre: + // OK, except with the pessimistic operator + case !cPre && !vPre: + // OK + } + return true +} + +//------------------------------------------------------------------- +// Constraint functions +//------------------------------------------------------------------- + +func constraintEqual(v, c *Version) bool { + return v.Equal(c) +} + +func constraintNotEqual(v, c *Version) bool { + return !v.Equal(c) +} + +func constraintGreaterThan(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) == 1 +} + +func constraintLessThan(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) == -1 +} + +func constraintGreaterThanEqual(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) >= 0 +} + +func constraintLessThanEqual(v, c *Version) bool { + return prereleaseCheck(v, c) && v.Compare(c) <= 0 +} + +func constraintPessimistic(v, c *Version) bool { + // Using a pessimistic constraint with a pre-release, restricts versions to pre-releases + if !prereleaseCheck(v, c) || (c.Prerelease() != "" && v.Prerelease() == "") { + return false + } + + // If the version being checked is naturally less than the constraint, then there + // is no way for the version to be valid against the constraint + if v.LessThan(c) { + return false + } + // We'll use this more than once, so grab the length now so it's a little cleaner + // to write the later checks + cs := len(c.segments) + + // If the version being checked has less specificity than the constraint, then there + // is no way for the version to be valid against the constraint + if cs > len(v.segments) { + return false + } + + // Check the segments in the constraint against those in the version. If the version + // being checked, at any point, does not have the same values in each index of the + // constraints segments, then it cannot be valid against the constraint. + for i := 0; i < c.si-1; i++ { + if v.segments[i] != c.segments[i] { + return false + } + } + + // Check the last part of the segment in the constraint. If the version segment at + // this index is less than the constraints segment at this index, then it cannot + // be valid against the constraint + if c.segments[cs-1] > v.segments[cs-1] { + return false + } + + // If nothing has rejected the version by now, it's valid + return true +} diff --git a/vendor/github.com/hashicorp/go-version/go.mod b/vendor/github.com/hashicorp/go-version/go.mod new file mode 100644 index 0000000..f528555 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/go.mod @@ -0,0 +1 @@ +module github.com/hashicorp/go-version diff --git a/vendor/github.com/hashicorp/go-version/version.go b/vendor/github.com/hashicorp/go-version/version.go new file mode 100644 index 0000000..8068834 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/version.go @@ -0,0 +1,392 @@ +package version + +import ( + "bytes" + "fmt" + "reflect" + "regexp" + "strconv" + "strings" +) + +// The compiled regular expression used to test the validity of a version. +var ( + versionRegexp *regexp.Regexp + semverRegexp *regexp.Regexp +) + +// The raw regular expression string used for testing the validity +// of a version. +const ( + VersionRegexpRaw string = `v?([0-9]+(\.[0-9]+)*?)` + + `(-([0-9]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)|(-?([A-Za-z\-~]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)))?` + + `(\+([0-9A-Za-z\-~]+(\.[0-9A-Za-z\-~]+)*))?` + + `?` + + // SemverRegexpRaw requires a separator between version and prerelease + SemverRegexpRaw string = `v?([0-9]+(\.[0-9]+)*?)` + + `(-([0-9]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)|(-([A-Za-z\-~]+[0-9A-Za-z\-~]*(\.[0-9A-Za-z\-~]+)*)))?` + + `(\+([0-9A-Za-z\-~]+(\.[0-9A-Za-z\-~]+)*))?` + + `?` +) + +// Version represents a single version. +type Version struct { + metadata string + pre string + segments []int64 + si int + original string +} + +func init() { + versionRegexp = regexp.MustCompile("^" + VersionRegexpRaw + "$") + semverRegexp = regexp.MustCompile("^" + SemverRegexpRaw + "$") +} + +// NewVersion parses the given version and returns a new +// Version. +func NewVersion(v string) (*Version, error) { + return newVersion(v, versionRegexp) +} + +// NewSemver parses the given version and returns a new +// Version that adheres strictly to SemVer specs +// https://semver.org/ +func NewSemver(v string) (*Version, error) { + return newVersion(v, semverRegexp) +} + +func newVersion(v string, pattern *regexp.Regexp) (*Version, error) { + matches := pattern.FindStringSubmatch(v) + if matches == nil { + return nil, fmt.Errorf("Malformed version: %s", v) + } + segmentsStr := strings.Split(matches[1], ".") + segments := make([]int64, len(segmentsStr)) + si := 0 + for i, str := range segmentsStr { + val, err := strconv.ParseInt(str, 10, 64) + if err != nil { + return nil, fmt.Errorf( + "Error parsing version: %s", err) + } + + segments[i] = int64(val) + si++ + } + + // Even though we could support more than three segments, if we + // got less than three, pad it with 0s. This is to cover the basic + // default usecase of semver, which is MAJOR.MINOR.PATCH at the minimum + for i := len(segments); i < 3; i++ { + segments = append(segments, 0) + } + + pre := matches[7] + if pre == "" { + pre = matches[4] + } + + return &Version{ + metadata: matches[10], + pre: pre, + segments: segments, + si: si, + original: v, + }, nil +} + +// Must is a helper that wraps a call to a function returning (*Version, error) +// and panics if error is non-nil. +func Must(v *Version, err error) *Version { + if err != nil { + panic(err) + } + + return v +} + +// Compare compares this version to another version. This +// returns -1, 0, or 1 if this version is smaller, equal, +// or larger than the other version, respectively. +// +// If you want boolean results, use the LessThan, Equal, +// GreaterThan, GreaterThanOrEqual or LessThanOrEqual methods. +func (v *Version) Compare(other *Version) int { + // A quick, efficient equality check + if v.String() == other.String() { + return 0 + } + + segmentsSelf := v.Segments64() + segmentsOther := other.Segments64() + + // If the segments are the same, we must compare on prerelease info + if reflect.DeepEqual(segmentsSelf, segmentsOther) { + preSelf := v.Prerelease() + preOther := other.Prerelease() + if preSelf == "" && preOther == "" { + return 0 + } + if preSelf == "" { + return 1 + } + if preOther == "" { + return -1 + } + + return comparePrereleases(preSelf, preOther) + } + + // Get the highest specificity (hS), or if they're equal, just use segmentSelf length + lenSelf := len(segmentsSelf) + lenOther := len(segmentsOther) + hS := lenSelf + if lenSelf < lenOther { + hS = lenOther + } + // Compare the segments + // Because a constraint could have more/less specificity than the version it's + // checking, we need to account for a lopsided or jagged comparison + for i := 0; i < hS; i++ { + if i > lenSelf-1 { + // This means Self had the lower specificity + // Check to see if the remaining segments in Other are all zeros + if !allZero(segmentsOther[i:]) { + // if not, it means that Other has to be greater than Self + return -1 + } + break + } else if i > lenOther-1 { + // this means Other had the lower specificity + // Check to see if the remaining segments in Self are all zeros - + if !allZero(segmentsSelf[i:]) { + //if not, it means that Self has to be greater than Other + return 1 + } + break + } + lhs := segmentsSelf[i] + rhs := segmentsOther[i] + if lhs == rhs { + continue + } else if lhs < rhs { + return -1 + } + // Otherwis, rhs was > lhs, they're not equal + return 1 + } + + // if we got this far, they're equal + return 0 +} + +func allZero(segs []int64) bool { + for _, s := range segs { + if s != 0 { + return false + } + } + return true +} + +func comparePart(preSelf string, preOther string) int { + if preSelf == preOther { + return 0 + } + + var selfInt int64 + selfNumeric := true + selfInt, err := strconv.ParseInt(preSelf, 10, 64) + if err != nil { + selfNumeric = false + } + + var otherInt int64 + otherNumeric := true + otherInt, err = strconv.ParseInt(preOther, 10, 64) + if err != nil { + otherNumeric = false + } + + // if a part is empty, we use the other to decide + if preSelf == "" { + if otherNumeric { + return -1 + } + return 1 + } + + if preOther == "" { + if selfNumeric { + return 1 + } + return -1 + } + + if selfNumeric && !otherNumeric { + return -1 + } else if !selfNumeric && otherNumeric { + return 1 + } else if !selfNumeric && !otherNumeric && preSelf > preOther { + return 1 + } else if selfInt > otherInt { + return 1 + } + + return -1 +} + +func comparePrereleases(v string, other string) int { + // the same pre release! + if v == other { + return 0 + } + + // split both pre releases for analyse their parts + selfPreReleaseMeta := strings.Split(v, ".") + otherPreReleaseMeta := strings.Split(other, ".") + + selfPreReleaseLen := len(selfPreReleaseMeta) + otherPreReleaseLen := len(otherPreReleaseMeta) + + biggestLen := otherPreReleaseLen + if selfPreReleaseLen > otherPreReleaseLen { + biggestLen = selfPreReleaseLen + } + + // loop for parts to find the first difference + for i := 0; i < biggestLen; i = i + 1 { + partSelfPre := "" + if i < selfPreReleaseLen { + partSelfPre = selfPreReleaseMeta[i] + } + + partOtherPre := "" + if i < otherPreReleaseLen { + partOtherPre = otherPreReleaseMeta[i] + } + + compare := comparePart(partSelfPre, partOtherPre) + // if parts are equals, continue the loop + if compare != 0 { + return compare + } + } + + return 0 +} + +// Core returns a new version constructed from only the MAJOR.MINOR.PATCH +// segments of the version, without prerelease or metadata. +func (v *Version) Core() *Version { + segments := v.Segments64() + segmentsOnly := fmt.Sprintf("%d.%d.%d", segments[0], segments[1], segments[2]) + return Must(NewVersion(segmentsOnly)) +} + +// Equal tests if two versions are equal. +func (v *Version) Equal(o *Version) bool { + if v == nil || o == nil { + return v == o + } + + return v.Compare(o) == 0 +} + +// GreaterThan tests if this version is greater than another version. +func (v *Version) GreaterThan(o *Version) bool { + return v.Compare(o) > 0 +} + +// GreaterThanOrEqual tests if this version is greater than or equal to another version. +func (v *Version) GreaterThanOrEqual(o *Version) bool { + return v.Compare(o) >= 0 +} + +// LessThan tests if this version is less than another version. +func (v *Version) LessThan(o *Version) bool { + return v.Compare(o) < 0 +} + +// LessThanOrEqual tests if this version is less than or equal to another version. +func (v *Version) LessThanOrEqual(o *Version) bool { + return v.Compare(o) <= 0 +} + +// Metadata returns any metadata that was part of the version +// string. +// +// Metadata is anything that comes after the "+" in the version. +// For example, with "1.2.3+beta", the metadata is "beta". +func (v *Version) Metadata() string { + return v.metadata +} + +// Prerelease returns any prerelease data that is part of the version, +// or blank if there is no prerelease data. +// +// Prerelease information is anything that comes after the "-" in the +// version (but before any metadata). For example, with "1.2.3-beta", +// the prerelease information is "beta". +func (v *Version) Prerelease() string { + return v.pre +} + +// Segments returns the numeric segments of the version as a slice of ints. +// +// This excludes any metadata or pre-release information. For example, +// for a version "1.2.3-beta", segments will return a slice of +// 1, 2, 3. +func (v *Version) Segments() []int { + segmentSlice := make([]int, len(v.segments)) + for i, v := range v.segments { + segmentSlice[i] = int(v) + } + return segmentSlice +} + +// Segments64 returns the numeric segments of the version as a slice of int64s. +// +// This excludes any metadata or pre-release information. For example, +// for a version "1.2.3-beta", segments will return a slice of +// 1, 2, 3. +func (v *Version) Segments64() []int64 { + result := make([]int64, len(v.segments)) + copy(result, v.segments) + return result +} + +// String returns the full version string included pre-release +// and metadata information. +// +// This value is rebuilt according to the parsed segments and other +// information. Therefore, ambiguities in the version string such as +// prefixed zeroes (1.04.0 => 1.4.0), `v` prefix (v1.0.0 => 1.0.0), and +// missing parts (1.0 => 1.0.0) will be made into a canonicalized form +// as shown in the parenthesized examples. +func (v *Version) String() string { + var buf bytes.Buffer + fmtParts := make([]string, len(v.segments)) + for i, s := range v.segments { + // We can ignore err here since we've pre-parsed the values in segments + str := strconv.FormatInt(s, 10) + fmtParts[i] = str + } + fmt.Fprintf(&buf, strings.Join(fmtParts, ".")) + if v.pre != "" { + fmt.Fprintf(&buf, "-%s", v.pre) + } + if v.metadata != "" { + fmt.Fprintf(&buf, "+%s", v.metadata) + } + + return buf.String() +} + +// Original returns the original parsed version as-is, including any +// potential whitespace, `v` prefix, etc. +func (v *Version) Original() string { + return v.original +} diff --git a/vendor/github.com/hashicorp/go-version/version_collection.go b/vendor/github.com/hashicorp/go-version/version_collection.go new file mode 100644 index 0000000..cc888d4 --- /dev/null +++ b/vendor/github.com/hashicorp/go-version/version_collection.go @@ -0,0 +1,17 @@ +package version + +// Collection is a type that implements the sort.Interface interface +// so that versions can be sorted. +type Collection []*Version + +func (v Collection) Len() int { + return len(v) +} + +func (v Collection) Less(i, j int) bool { + return v[i].LessThan(v[j]) +} + +func (v Collection) Swap(i, j int) { + v[i], v[j] = v[j], v[i] +} diff --git a/vendor/modules.txt b/vendor/modules.txt new file mode 100644 index 0000000..0da048f --- /dev/null +++ b/vendor/modules.txt @@ -0,0 +1,20 @@ +# github.com/bitrise-io/go-android v0.0.0-20210527143215-3ad22ad02e2e +## explicit +github.com/bitrise-io/go-android/sdk +# github.com/bitrise-io/go-steputils v0.0.0-20210514150206-5b6261447e77 +## explicit +github.com/bitrise-io/go-steputils/stepconf +github.com/bitrise-io/go-steputils/tools +# github.com/bitrise-io/go-utils v0.0.0-20210520073355-367fa34178f5 +## explicit +github.com/bitrise-io/go-utils/colorstring +github.com/bitrise-io/go-utils/command +github.com/bitrise-io/go-utils/log +github.com/bitrise-io/go-utils/parseutil +github.com/bitrise-io/go-utils/pathutil +github.com/bitrise-io/go-utils/pointers +# github.com/hashicorp/go-version v1.3.0 +github.com/hashicorp/go-version +# github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 +## explicit +github.com/kballard/go-shellquote