fastlane-plugin-shuttle 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 602fcbb57374635eb54413662526bb1cbb5eb92e
+  data.tar.gz: 1337002082164db30a5e3dfe6a1edbd6d32497b7
+SHA512:
+  metadata.gz: ac11b3760899ffb20832691a6e1b61967b93e74ad07d950a219298fadfd1542134eaf0bc15629630c059544c53c94f7f301ded0488ce5f8cf75d5721ff8fdfc9
+  data.tar.gz: cce1ed5253fbae930f1b660403f6e6b6325eaec4b71ab2846641d09dde957eade498f239c62f124ab7552069f54f1a43a70ff8a3b1ae025c91a709f421f89680

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Frédéric Ruaudel <fred@h2g.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Shuttle `fastlane` plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-shuttle) [![Gem Version](https://badge.fury.io/rb/fastlane-plugin-shuttle.svg)](https://badge.fury.io/rb/fastlane-plugin-shuttle)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-shuttle`, add it to your project by running:
+
+```bash
+fastlane add_plugin shuttle
+```
+
+## About Shuttle
+
+Publish your builds on your [Shuttle.tools](https://shuttle.tools) instance
+
+This plugin provides a `shuttle` action which allows you to upload and distribute your apps to your testers via your Shuttle instance interface.
+
+## Usage
+
+To get started, first, [obtain an API access token](https://docs.shuttle.tools/api-access-token/) in your Shuttle instance admin section. The API Access Token is used to authenticate with the Shuttle API in each call.
+
+```ruby
+url = shuttle(
+      access_token: <shuttle access token>,
+      package_path: <path to your IPA or APK binary file>,
+      release_name: <release name displayed in shuttle>,
+      release_notes: <release notes>,
+      base_url: "https://<your instance name>.shuttle.tools/")
+```
+
+The action parameters `access_token` can be omitted when its value is [set as environment variables](https://docs.fastlane.tools/advanced/#environment-variables). Below a list of all available environment variables:
+
+- `SHUTTLE_ACCESS_TOKEN` - API Access Token for Shuttle API
+- `SHUTTLE_BASE_URL` - Shuttle instance URL (eg. https://<your instance name>.shuttle.tools/)
+- `SHUTTLE_RELEASE_NAME` - The name of the release (eg. MyApp v3)
+- `SHUTTLE_PACKAGE_PATH` - Build release path for android or ios build (if not provided, it'll check in shared values `GRADLE_APK_OUTPUT_PATH` or `IPA_OUTPUT_PATH`)
+- `SHUTTLE_ENV_ID` - The uniq ID of the app's environment you want to publish the build to (if not provided, it will try to guess it or ask to select/create it interactively then display the value so you can set it definitively)
+- `SHUTTLE_RELEASE_NOTES` - Release notes
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/shuttle.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/shuttle/version'
+
+module Fastlane
+  module Shuttle
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Shuttle.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/shuttle/actions/shuttle_action.rb

@@ -0,0 +1,138 @@
+require 'fastlane/action'
+require_relative '../helper/shuttle_helper'
+require_relative '../helper/app_environment_selector'
+require 'faraday'
+require 'json'
+require 'app-info'
+require 'terminal-table'
+
+ShuttleInstance = Struct.new(:base_url, :access_token)
+ShuttleApp = Struct.new(:id, :name, :platform_id, :path)
+ShuttleEnvironment = Struct.new(:id, :name, :package_id, :app_id, :versioning_id, :path)
+ShuttleBuild = Struct.new(:id)
+AppEnvironment = Struct.new(:shuttle_app, :shuttle_environment)
+PackageInfo = Struct.new(:id, :name, :path, :platform_id, :release_version, :build_version)
+ReleaseInfo = Struct.new(:name, :notes, :build, :environment, :commit_id)
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SHUTTLE_DOWNLOAD_LINK = :SHUTTLE_DOWNLOAD_LINK
+    end
+
+    class ShuttleAction < Action
+      def self.run(params)
+        helper = Helper::ShuttleHelper
+        selector = Helper::AppEnvironmentSelector
+        shuttle_instance = helper.get_shuttle_instance(params)
+        package_info = helper.get_app_info(params)
+        
+        UI.message("Uploading #{package_info.platform_id} package #{package_info.path} with ID #{package_info.id}…")
+
+        app_environment = selector.get_app_environment(shuttle_instance, package_info, params)
+        
+        release = helper.get_release_info(params, app_environment, package_info)
+
+        helper.print_summary_table(shuttle_instance, app_environment, package_info, release)
+
+        release.build = helper.upload_build(shuttle_instance, package_info, app_environment.shuttle_app.id)
+
+        helper.create_release(shuttle_instance, release)
+
+        download_url = helper.download_url(shuttle_instance, app_environment, package_info)
+        Actions.lane_context[SharedValues::SHUTTLE_DOWNLOAD_LINK] = download_url
+
+        return download_url
+      end
+
+      def self.description
+        "Publish your builds on [Shuttle.tools](https://www.shuttle.tools)"
+      end
+
+      def self.authors
+        ["Frédéric Ruaudel <fred@h2g.io>"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+        "Shuttle download link"
+      end
+
+      def self.details
+        # Optional:
+        [
+          "If you don't know which `env_id` to set, just run the action interactively without `env_id` parameter to force the plugin to fetch available info from your instance or give you the opportunity to create any needed app and environment that would be missing.",
+          "Once done, you will get the associated `env_id` in the _Shuttle upload info summary_ table at the end of the script execution. Just add it in your action parameter to make it works reliably next time including in your CI non-interactive environment"
+        ].join("\n")
+      end
+
+      def self.output
+        [
+          ['SHUTTLE_DOWNLOAD_LINK', 'The newly generated download link for this build']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :package_path,
+                                  env_name: "SHUTTLE_PACKAGE_PATH",
+                               description: "The path to the new app you want to upload to Shuttle ( if not provided, it'll check in shared values GRADLE_APK_OUTPUT_PATH or IPA_OUTPUT_PATH)",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :base_url,
+                                  env_name: "SHUTTLE_BASE_URL",
+                               description: "The base url of your Shuttle instance",
+                                  optional: false,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :access_token,
+                                  env_name: "SHUTTLE_ACCESS_TOKEN",
+                               description: "The access token of your account on Shuttle",
+                                  optional: false,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :release_name,
+                                  env_name: "SHUTTLE_RELEASE_NAME",
+                               description: "The name of the release (eg. MyApp v3)",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+                                  env_name: "SHUTTLE_RELEASE_NOTES",
+                               description: "The release notes of the release (eg. Bug fixes)",
+                                  optional: true,
+                             default_value: "Bug fixes and improvements",
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :env_id,
+                                  env_name: "SHUTTLE_ENV_ID",
+                               description: "The uniq ID of the app's environment you want to publish the build to (if not provided, it will try to guess it or ask to select/create it interactively then display the value so you can set it definitively)",
+                                  optional: true,
+                                      type: String),                                      
+        ]
+      end
+
+      def self.example_code
+        [
+          'download_url = shuttle(
+            access_token: "...",
+            base_url: "https://myInstance.shuttle.tools",
+            package_path: "./app.ipa"
+          )',
+          'shuttle(
+            access_token: "...",
+            base_url: "https://myInstance.shuttle.tools",
+            package_path: "./app.ipa",
+            env_id: "UD6VCR-2X7TME-XSMZW6-MNXIR7",
+            release_name: "My App v5.0-1",
+            release_notes: "Changelog"
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/shuttle/helper/app_environment_selector.rb

@@ -0,0 +1,118 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class AppEnvironmentSelector
+      # class methods that you define here become available in your action
+      # as `Helper::ShuttleHelper.your_method`
+      #
+      def self.get_app_environment(shuttle_instance, package_info, params) 
+        helper = Helper::ShuttleHelper
+        
+        app_environment = self.get_app_env_from_params(shuttle_instance, package_info, params, helper)
+        return app_environment unless app_environment.nil?
+
+        all_environments = helper.get_environments(shuttle_instance)
+
+        app_environment = nil
+        environments = all_environments.select do |env|
+          env.package_id == package_info.id
+        end
+
+        app_environments = helper.get_app_environments(shuttle_instance, environments).select do |app_env|
+          app_env.shuttle_app.platform_id == package_info.platform_id
+        end
+        
+        if app_environments.empty?
+          app = self.get_app_interactive(shuttle_instance, package_info, helper)
+          env = self.get_env_interactive(shuttle_instance, app, package_info, helper)
+          app_environment = AppEnvironment.new(app, env)
+        else
+          if app_environments.count == 1 
+            app_environment = app_environments[0]
+          else
+            app_environment = self.desambiguate_app_environment(app_environments, package_info, helper)
+          end
+        end
+
+        return app_environment
+      end
+
+      def self.get_app_env_from_params(shuttle_instance, package_info, params, helper)
+        env_id = params[:env_id]
+        return nil if env_id.to_s.empty?
+        environment = helper.get_environment(shuttle_instance, env_id)
+        app = helper.get_app(shuttle_instance, environment.app_id)
+          
+        return AppEnvironment.new(app, environment) if environment.package_id == package_info.id && app.platform_id == package_info.platform_id
+          
+        UI.important("App #{app.name} doesn't match the given build platform #{package_info.platform_id}, please check that #{env_id} is the correct environment ID.") unless app.platform_id == package_info.platform_id
+        UI.important("Environement #{environment.name} with ID #{env_id} doesn't match the build's package ID #{package_info.id}, please check that you set the correct environment ID") unless environment.package_id == package_info.id
+        return nil
+      end
+
+      def self.desambiguate_app_environment(app_environments, package_info, helper)
+        options = app_environments.map do |app_env|
+          "#{app_env.shuttle_app.name} (#{app_env.shuttle_environment.name})"
+        end
+        choice_index = helper.prompt_choices(
+            "Can't guess which app and environment to use, please choose the correct one:",
+            options, 
+            "Too many environments with package id #{package_info.id} for #{package_info.platform_id}"
+        )
+        app_environment = app_environments[choice_index]
+      end
+
+      def self.get_app_interactive(shuttle_instance, package_info, helper)
+        apps = helper.get_apps(shuttle_instance).select do |app|
+          app.platform_id == package_info.platform_id
+        end
+        options = apps.map do |app|
+          "#{app.name}"
+        end
+        create_new_option = "Create a new one…"
+        choice_index = helper.prompt_choices(
+            "Can't guess which app to use, please choose the correct one:",
+            options << create_new_option, 
+            "No environments configured for package id #{package_info.id}"
+        )
+        return self.create_app_interactive(shuttle_instance, package_info, helper) if options[choice_index] == create_new_option
+        return apps[choice_index]
+      end
+
+      def self.create_app_interactive(shuttle_instance, package_info, helper)
+        app_name = UI.input("app name (default: #{package_info.name}): ")
+        app_name = package_info.name if app_name.to_s.empty?
+        helper.create_app(shuttle_instance, app_name, package_info.platform_id)
+      end
+
+      def self.get_env_interactive(shuttle_instance, app, package_info, helper)
+        environments = helper.get_environments_for_app(shuttle_instance, app).select do |env|
+          env.package_id == package_info.id
+        end
+        options = environments.map do |env|
+          "#{env.name}"
+        end
+        create_new_option = "Create a new one…"
+        choice_index = helper.prompt_choices(
+            "Can't guess which #{app.name}'s environment to use, please choose the correct one:",
+            options << create_new_option, 
+            "No environments configured for package id #{package_info.id}"
+        )
+        return self.create_environment_interactive(shuttle_instance, app, package_info, helper) if options[choice_index] == create_new_option
+        return environments[choice_index]
+      end
+
+      def self.create_environment_interactive(shuttle_instance, app, package_info, helper)
+        env_name = UI.input("environment name: ")
+        versioning_id_choices = ["version_only", "version_and_build"]
+        choice_index = helper.prompt_choices("environment version scheme:", versioning_id_choices, "interactive mode needed")
+        app_name = package_info.name if app_name.to_s.empty?
+        helper.create_environment(shuttle_instance, env_name, versioning_id_choices[choice_index], app.id, package_info.id)
+      end
+
+    end
+  end
+end

data/lib/fastlane/plugin/shuttle/helper/shuttle_helper.rb

@@ -0,0 +1,300 @@
+require 'fastlane_core/ui/ui'
+require 'fastlane/action'
+require 'uri'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class ShuttleHelper
+      # class methods that you define here become available in your action
+      # as `Helper::ShuttleHelper.your_method`
+      #
+      def self.get_shuttle_instance(params) 
+        shuttle_base_url = params[:base_url]
+        shuttle_access_token = params[:access_token]
+        ShuttleInstance.new(shuttle_base_url, shuttle_access_token)
+      end
+
+      def self.get_app_info(params)
+        package_path = params[:package_path] unless params[:package_path].to_s.empty?
+        package_path = Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::IPA_OUTPUT_PATH] if package_path.to_s.empty?
+        package_path = Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::GRADLE_APK_OUTPUT_PATH] if package_path.to_s.empty?
+        UI.abort_with_message!("No Package file found") if package_path.to_s.empty?
+        UI.abort_with_message!("Package at path #{package_path} does not exist") unless File.exist?(package_path)
+        app_info = ::AppInfo.parse(package_path)
+        PackageInfo.new(app_info.identifier, app_info.name, package_path, app_info.os.downcase, app_info.release_version, app_info.build_version)
+      end
+
+      def self.get_release_name(params, app_environment, package_info)
+        return params[:release_name] unless params[:release_name].to_s.empty?
+        release_name = "#{app_environment.shuttle_app.name} v#{package_info.release_version}"
+        if app_environment.shuttle_environment.versioning_id == "version_and_build"
+          return "#{release_name}-#{package_info.build_version}"
+        end 
+        return release_name
+      end
+
+      def self.get_release_info(params, app_environment, package_info) 
+        release_name = self.get_release_name(params, app_environment, package_info)
+        commit_id = Helper.backticks("git show --format='%H' --quiet").chomp
+        ReleaseInfo.new(release_name, params[:release_notes], nil, app_environment.shuttle_environment, commit_id)
+      end
+
+      def self.connection(shuttle_instance, endpoint, is_multipart = false)
+        return Faraday.new(url: "#{shuttle_instance.base_url}/api#{endpoint}") do |builder|
+          # builder.response :logger, Logger.new(STDOUT), bodies: true
+          builder.headers["Authorization"] = "Bearer #{shuttle_instance.access_token}"
+          builder.headers["Accept"] = "application/vnd.api+json"
+          if is_multipart
+            builder.request :multipart
+          else
+            builder.headers["Content-Type"] = "application/vnd.api+json"
+          end
+          builder.adapter :net_http
+        end
+      end
+
+      def self.get(shuttle_instance, endpoint, debug=false) 
+        connection = self.connection(shuttle_instance, endpoint)
+        response = connection.get()
+        case response.status
+        when 200...300
+          data = JSON.parse(response.body)
+          UI.message("Debug: #{JSON.pretty_generate(data["data"])}\n") if debug == true
+          data["data"]
+        else 
+          UI.abort_with_message!("Error #{response.status.to_s} occured while calling endpoint #{endpoint}")
+          nil
+        end
+      end
+
+      def self.environment_from_json(json_env)
+        attrb = json_env["attributes"]
+        ShuttleEnvironment.new(
+          json_env["id"],
+          attrb["name"],
+          attrb["package_id"],
+          json_env["relationships"]["app"]["data"]["id"],
+          attrb["versioning_id"],
+          attrb["path"]
+        )
+      end
+
+      def self.get_environments(shuttle_instance)
+        self.get(shuttle_instance, '/environments').map do |json_env|
+          self.environment_from_json(json_env)
+        end
+      end
+
+      def self.get_environment(shuttle_instance, env_id)
+        json_env = self.get(shuttle_instance, "/environments/#{env_id}")
+        self.environment_from_json(json_env)
+      end
+
+      def self.get_environments_for_app(shuttle_instance, app)
+        self.get(shuttle_instance, "/apps/#{app.id}/environments").map do |json_env|
+          self.environment_from_json(json_env)
+        end
+      end
+
+      def self.create_environment(shuttle_instance, name, versioning_id, app_id, package_id)
+        body = JSON.generate({
+          data: {
+            type: "environments",
+            attributes: {
+              name: name,
+              path: name.downcase,
+              package_id: package_id,
+              versioning_id: versioning_id
+            },
+            relationships: {
+              app: {
+                data: {
+                  id: app_id,
+                  type: "apps"
+                }
+              }
+            }
+          }
+        })
+        json_env = self.post(shuttle_instance, "/environments", body)
+        self.environment_from_json(json_env)
+      end
+
+      def self.app_from_json(json_app)
+        json_app_attrb = json_app["attributes"]
+        ShuttleApp.new(
+          json_app["id"],
+          json_app_attrb["name"],
+          json_app_attrb["platform_id"],
+          json_app_attrb["path"]
+        )
+      end
+
+      def self.get_apps(shuttle_instance)
+        self.get(shuttle_instance, "/apps/").map do |json_app|
+          self.app_from_json(json_app)
+        end
+      end
+
+      def self.get_app(shuttle_instance, app_id)
+        json_app = self.get(shuttle_instance, "/apps/#{app_id}")
+        self.app_from_json(json_app)
+      end
+
+      def self.create_app(shuttle_instance, app_name, app_platform)
+        app_path = "#{app_name.downcase}-#{app_platform}"
+        body = JSON.generate({
+          data: {
+            type: "apps",
+            attributes: {
+              name: app_name,
+              path: app_path,
+              platform_id: app_platform
+            }
+          }
+        })
+        json_app = self.post(shuttle_instance, "/apps", body)
+        self.app_from_json(json_app)
+      end
+
+      def self.get_app_environments(shuttle_instance, environments)
+        apps = environments.map do |env| 
+          self.get_app(shuttle_instance, env.app_id)
+        end
+
+        apps.zip(environments).map do |app_env| 
+          AppEnvironment.new(
+            app_env[0],
+            app_env[1]
+          )
+        end
+      end
+
+      def self.post(shuttle_instance, endpoint, body, is_multipart: false, debug: false)
+        connection = self.connection(shuttle_instance, endpoint, is_multipart)
+        response = connection.post do |req|
+          req.body = body
+        end
+        case response.status
+        when 200...300
+          data = JSON.parse response.body
+          UI.message(JSON.pretty_generate(data)) if debug == true
+          data["data"]
+        else
+          self.abort(endpoint, body, response)
+          nil
+        end
+      end
+
+      def self.abort(endpoint, body, response)
+        reqBody = JSON.parse body
+        errorBody = JSON.parse response.body
+        case endpoint
+        when "/releases"
+          UI.abort_with_message!("💥 Can't create release for #{reqBody["data"]["attributes"]["title"]}: #{errorBody["errors"][0]["detail"]}")
+        else
+          UI.abort_with_message!("Error #{response.status.to_s} occured while calling endpoint #{endpoint} with body #{body} => #{errorBody["errors"][0]["detail"]}")
+        end
+      end 
+
+      def self.upload_build(shuttle_instance, package_info, app_id)
+        body = {
+          "build[app_id]": app_id,
+          "build[package]": Faraday::UploadIO.new(package_info.path, 'application/octet-stream')
+        }
+        json_build = self.post(shuttle_instance, '/builds', body, is_multipart: true)
+        ShuttleBuild.new(json_build["id"])
+      end
+
+      def self.create_release(shuttle_instance, release)
+        body = JSON.generate({
+          data: {
+            type: "releases",
+            attributes: {
+              title: release.name,
+              notes: release.notes,
+              commit_id: release.commit_id
+            },
+            relationships: {
+              build: {
+                data: {
+                  id: release.build.id,
+                  type: "builds"
+                }
+              },
+              environment: {
+                data: {
+                  id: release.environment.id,
+                  type: "environments"
+                }
+              }
+            }
+          }
+        })
+        json_release = self.post(shuttle_instance, "/releases", body)
+      end
+
+      def self.prompt_choices(question, options, nonInteractiveErrorMessage) 
+        UI.abort_with_message!(nonInteractiveErrorMessage) unless UI.interactive?
+          abort_option = "None match, abort"
+          user_choice = UI.select question, options << abort_option
+          case user_choice
+          when abort_option
+            UI.user_error!("Aborting…")
+          else
+            choice_index = options.find_index(user_choice)
+          end
+      end
+
+      def self.download_url(shuttle_instance, app_environment, package_info)
+        app = app_environment.shuttle_app
+        env = app_environment.shuttle_environment
+        url_path = File.join(
+                      app.path, 
+                      env.path,
+                      package_info.release_version)
+        url_path = File.join(url_path, package_info.build_version) if env.versioning_id == "version_and_build"
+        return URI.join(
+          shuttle_instance.base_url, url_path).to_s
+      end
+
+      def self.print_summary_table(shuttle_instance, app_environment, package_info, release)
+        rows = [
+          'Shuttle Base URL', 
+          'Shuttle app name', 
+          'Shuttle env name', 
+          'Shuttle env ID', 
+          'Package path', 
+          'Platform', 
+          'Package Id',
+          'Release name',
+          'Release version',
+          'Build version',
+          'Release notes',
+          'Commit hash',
+          'Shuttle release URL'
+        ].zip([
+            shuttle_instance.base_url, 
+            app_environment.shuttle_app.name,
+            app_environment.shuttle_environment.name, 
+            app_environment.shuttle_environment.id, 
+            package_info.path, 
+            package_info.platform_id, 
+            package_info.id,
+            release.name,
+            package_info.release_version,
+            package_info.build_version,
+            release.notes,
+            release.commit_id,
+            self.download_url(shuttle_instance, app_environment, package_info)
+        ])
+        table = Terminal::Table.new :rows => rows, :title => "Shuttle upload info summary".green
+        puts
+        puts table
+        puts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Shuttle
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-shuttle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shuttle Project
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: app-info
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.97.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.97.0
+description: 
+email: dev@shuttle.tools
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/shuttle.rb
+- lib/fastlane/plugin/shuttle/actions/shuttle_action.rb
+- lib/fastlane/plugin/shuttle/helper/app_environment_selector.rb
+- lib/fastlane/plugin/shuttle/helper/shuttle_helper.rb
+- lib/fastlane/plugin/shuttle/version.rb
+homepage: https://github.com/ShuttleProject/fastlane-plugin-shuttle
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Publish your builds on Shuttle.tools
+test_files: []