fastlane-plugin-appcenter 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48df8a17edb752b7e11b38125b5e205971e9e2be
+  data.tar.gz: 7a0672dd1a6250ce6225a42c23cb30ac74e82177
+SHA512:
+  metadata.gz: 29d4b4696c8cacdee4e2ad44ea52b806a77ff60fabee8ef4da0516688016f855caa2895a367348cdc8fffb9c750603b89098c45e77d295dcd7fd5295a0859b26
+  data.tar.gz: 69e9c5a5bf119ad4afbced987b4522384ab9c56469e52d3c49d043d5d00e3bc3508ed6bbe955877830ae00512e930376165f73950b2ef252124bbf26328dec54

data/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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,84 @@
+# appcenter plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-appcenter)
+[![Gem Version](https://badge.fury.io/rb/fastlane-plugin-appcenter.svg)](https://badge.fury.io/rb/fastlane-plugin-appcenter)
+[![Build Status](https://travis-ci.org/Microsoft/fastlane-plugin-appcenter.svg?branch=master)](https://travis-ci.org/Microsoft/fastlane-plugin-appcenter)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-appcenter`, add it to your project by running:
+
+```bash
+fastlane add_plugin appcenter
+```
+
+## About appcenter
+
+Plugin for [App Center](https://appcenter.ms). Provides `appcenter_upload` action for [release distribution](https://docs.microsoft.com/en-us/appcenter/distribution/uploading) and [dSYM uploads](https://docs.microsoft.com/en-us/appcenter/crashes/ios)
+
+## Usage
+
+Obtain an [API token](https://docs.microsoft.com/en-us/appcenter/api-docs/). API Token is used for authentication for all App Center API calls.
+
+```ruby
+appcenter_upload(
+  api_token: "<appcenter token>",
+  owner_name: "<your appcenter account name>",
+  app_name: "<your app name>",
+  apk: "<path to android build binary>"
+)
+```
+
+## 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`.
+
+Sample uses `.env` for setting private variables like API token, owner name, .etc. You need to replace it in `Fastfile` by your own values.
+
+There are three examples in `test` lane:
+- upload release for android with minimum required parameters
+- upload release for ios with all set parameters
+- upload only dSYM file for ios
+
+## 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).
+
+## Contributing
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Contact
+
+### Intercom
+
+If you have further questions, want to provide feedback or you are running into issues, log in to the [App Center](https://appcenter.ms) portal and use the blue Intercom button on the bottom right to start a conversation with us.
+
+### Twitter
+
+We're on Twitter as [@appcenter](https://www.twitter.com/vsappcenter).

data/lib/fastlane/plugin/appcenter.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/appcenter/version'
+
+module Fastlane
+  module Appcenter
+    # 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::Appcenter.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/appcenter/actions/appcenter_upload_action.rb

@@ -0,0 +1,535 @@
+# rubocop:disable Metrics/ClassLength
+module Fastlane
+  module Actions
+    module SharedValues
+      APPCENTER_DOWNLOAD_LINK = :APPCENTER_DOWNLOAD_LINK
+      APPCENTER_BUILD_INFORMATION = :APPCENTER_BUILD_INFORMATION
+    end
+
+    class AppcenterUploadAction < Action
+      # create request
+      def self.connection(upload_url = false, dsym = false)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        options = {
+          url: upload_url ? upload_url : "https://api.appcenter.ms"
+        }
+
+        Faraday.new(options) do |builder|
+          if upload_url
+            builder.request :multipart unless dsym
+            builder.request :url_encoded unless dsym
+          else
+            builder.request :json
+          end
+          builder.response :json, content_type: /\bjson$/
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.adapter :net_http
+        end
+      end
+
+      # creates new release upload
+      # returns:
+      # upload_id
+      # upload_url
+      def self.create_release_upload(api_token, owner_name, app_name)
+        connection = self.connection
+
+        response = connection.post do |req|
+          req.url("/v0.1/apps/#{owner_name}/#{app_name}/release_uploads")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = {}
+        end
+
+        case response.status
+        when 200...300
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          response.body
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        when 404
+          UI.error("Not found, invalid owner or application name")
+          false
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # creates new dSYM upload in appcenter
+      # returns:
+      # symbol_upload_id
+      # upload_url
+      # expiration_date
+      def self.create_dsym_upload(api_token, owner_name, app_name)
+        connection = self.connection
+
+        response = connection.post do |req|
+          req.url("/v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = {
+            symbol_type: 'Apple'
+          }
+        end
+
+        case response.status
+        when 200...300
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          response.body
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        when 404
+          UI.error("Not found, invalid owner or application name")
+          false
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # committs or aborts dsym upload
+      def self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, status)
+        connection = self.connection
+
+        response = connection.patch do |req|
+          req.url("/v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = {
+            "status" => status
+          }
+        end
+
+        case response.status
+        when 200...300
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          response.body
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # upload dSYM files to specified upload url
+      # if succeed, then commits the upload
+      # otherwise aborts
+      def self.upload_dsym(api_token, owner_name, app_name, dsym, symbol_upload_id, upload_url)
+        connection = self.connection(upload_url, true)
+
+        response = connection.put do |req|
+          req.headers['x-ms-blob-type'] = "BlockBlob"
+          req.headers['Content-Length'] = File.size(dsym).to_s
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = Faraday::UploadIO.new(dsym, 'application/octet-stream') if dsym && File.exist?(dsym)
+        end
+
+        case response.status
+        when 200...300
+          self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
+          UI.success("dSYM uploaded")
+        else
+          UI.error("Error uploading dSYM #{response.status}: #{response.body}")
+          self.update_dsym_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
+          UI.error("dSYM upload aborted")
+          false
+        end
+      end
+
+      # upload binary for specified upload_url
+      # if succeed, then commits the release
+      # otherwise aborts
+      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url)
+        connection = self.connection(upload_url)
+
+        options = {}
+        options[:upload_id] = upload_id
+        # ipa field is used both for .apk and .ipa files
+        options[:ipa] = Faraday::UploadIO.new(file, 'application/octet-stream') if file && File.exist?(file)
+
+        response = connection.post do |req|
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = options
+        end
+
+        case response.status
+        when 200...300
+          UI.message("Binary uploaded")
+          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'committed')
+        else
+          UI.error("Error uploading binary #{response.status}: #{response.body}")
+          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'aborted')
+          UI.error("Release aborted")
+          false
+        end
+      end
+
+      # Commits or aborts the upload process for a release
+      def self.update_release_upload(api_token, owner_name, app_name, upload_id, status)
+        connection = self.connection
+
+        response = connection.patch do |req|
+          req.url("/v0.1/apps/#{owner_name}/#{app_name}/release_uploads/#{upload_id}")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = {
+            "status" => status
+          }
+        end
+
+        case response.status
+        when 200...300
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          response.body
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # add release to distribution group
+      def self.add_to_group(api_token, release_url, group_name, release_notes = '')
+        connection = self.connection
+
+        response = connection.patch do |req|
+          req.url("/#{release_url}")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = {
+            "distribution_group_name" => group_name,
+            "release_notes" => release_notes
+          }
+        end
+
+        case response.status
+        when 200...300
+          release = response.body
+          download_url = release['download_url']
+
+          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
+
+          Actions.lane_context[SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
+          Actions.lane_context[SharedValues::APPCENTER_BUILD_INFORMATION] = release
+
+          UI.message("Public Download URL: #{download_url}") if download_url
+          UI.success("Release #{release['short_version']} was successfully distributed")
+
+          release
+        when 404
+          UI.error("Not found, invalid distribution group name")
+          false
+        else
+          UI.error("Error adding to group #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # run whole upload process for dSYM files
+      def self.run_dsym_upload(params)
+        values = params.values
+        api_token = params[:api_token]
+        owner_name = params[:owner_name]
+        app_name = params[:app_name]
+        file = params[:ipa]
+        dsym = params[:dsym]
+
+        dsym_path = nil
+        if dsym
+          # we can use dsym parameter only if build file is ipa
+          dsym_path = dsym if !file || File.extname(file) == '.ipa'
+        else
+          # if dsym is note set, but build is ipa - check default path
+          if file && File.exist?(file) && File.extname(file) == '.ipa'
+            dsym_path = file.to_s.gsub('.ipa', '.dSYM.zip')
+            UI.message("dSYM is found")
+          end
+        end
+
+        # if we provided valid dsym path, or <ipa_path>.dSYM.zip was found, start dSYM upload
+        if dsym_path && File.exist?(dsym_path)
+          if File.directory?(dsym_path)
+            UI.message("dSYM path is folder, zipping...")
+            dsym_path = Actions::ZipAction.run(path: dsym, output_path: dsym + ".zip")
+            UI.message("dSYM files zipped")
+          end
+
+          values[:dsym_path] = dsym_path
+
+          UI.message("Starting dSYM upload...")
+          dsym_upload_details = self.create_dsym_upload(api_token, owner_name, app_name)
+
+          if dsym_upload_details
+            symbol_upload_id = dsym_upload_details['symbol_upload_id']
+            upload_url = dsym_upload_details['upload_url']
+
+            UI.message("Uploading dSYM...")
+            self.upload_dsym(api_token, owner_name, app_name, dsym_path, symbol_upload_id, upload_url)
+          end
+        end
+      end
+
+      # run whole upload process for release
+      def self.run_release_upload(params)
+        api_token = params[:api_token]
+        owner_name = params[:owner_name]
+        app_name = params[:app_name]
+        group = params[:group]
+
+        file = [
+          params[:ipa],
+          params[:apk]
+        ].detect { |e| !e.to_s.empty? }
+
+        UI.user_error!("Couldn't find build file at path '#{file}'") unless file && File.exist?(file)
+        UI.user_error!("No Distribute Group given, pass using `group: 'group name'`") unless group && !group.empty?
+
+        UI.message("Starting release upload...")
+        upload_details = self.create_release_upload(api_token, owner_name, app_name)
+        if upload_details
+          upload_id = upload_details['upload_id']
+          upload_url = upload_details['upload_url']
+
+          UI.message("Uploading release binary...")
+          uploaded = self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url)
+
+          if uploaded
+            release_url = uploaded['release_url']
+            UI.message("Release committed")
+            self.add_to_group(api_token, release_url, group, params[:release_notes])
+          end
+        end
+      end
+
+      # returns true if app exists, false in case of 404 and error otherwise
+      def self.get_app(api_token, owner_name, app_name)
+        connection = self.connection
+
+        response = connection.get do |req|
+          req.url("/v0.1/apps/#{owner_name}/#{app_name}")
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+        end
+
+        case response.status
+        when 200...300
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          true
+        when 404
+          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+          false
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # checks app existance, if ther is no such - creates it
+      def self.get_or_create_app(params)
+        api_token = params[:api_token]
+        owner_name = params[:owner_name]
+        app_name = params[:app_name]
+
+        platforms = {
+          "Android" => ['Java', 'React-Native', 'Xamarin'],
+          "iOS" => ['Objective-C-Swift', 'React-Native', 'Xamarin']
+        }
+
+        if self.get_app(api_token, owner_name, app_name)
+          true
+        else
+          if Helper.test? || UI.confirm("App with name #{app_name} not found, create one?")
+            connection = self.connection
+
+            os = Helper.test? ? "Android" : UI.select("Select OS", ["Android", "iOS"])
+            platform = Helper.test? ? "Java" : UI.select("Select Platform", platforms[os])
+
+            response = connection.post do |req|
+              req.url("/v0.1/apps")
+              req.headers['X-API-Token'] = api_token
+              req.headers['internal-request-source'] = "fastlane"
+              req.body = {
+                "display_name" => app_name,
+                "name" => app_name,
+                "os" => os,
+                "platform" => platform
+              }
+            end
+
+            case response.status
+            when 200...300
+              created = response.body
+              UI.message("DEBUG: #{JSON.pretty_generate(created)}") if ENV['DEBUG']
+              UI.success("Created #{os}/#{platform} app with name \"#{created['name']}\"")
+              true
+            else
+              UI.error("Error creating app #{response.status}: #{response.body}")
+              false
+            end
+          else
+            UI.error("Lane aborted")
+            false
+          end
+        end
+      end
+
+      def self.run(params)
+        values = params.values
+        upload_dsym_only = params[:upload_dsym_only]
+
+        # if app found or successfully created
+        if self.get_or_create_app(params)
+          self.run_release_upload(params) unless upload_dsym_only
+          self.run_dsym_upload(params)
+        end
+
+        return values if Helper.test?
+      end
+
+      def self.description
+        "Distribute new release to App Center"
+      end
+
+      def self.authors
+        ["Microsoft"]
+      end
+
+      def self.details
+        [
+          "Symbols will also be uploaded automatically if a `app.dSYM.zip` file is found next to `app.ipa`. In case it is located in a different place you can specify the path explicitly in `:dsym` parameter."
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                  env_name: "APPCENTER_API_TOKEN",
+                               description: "API Token for App Center",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                UI.user_error!("No API token for App Center given, pass using `api_token: 'token'`") unless value && !value.empty?
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :owner_name,
+                                  env_name: "APPCENTER_OWNER_NAME",
+                               description: "Owner name",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                UI.user_error!("No Owner name for App Center given, pass using `owner_name: 'name'`") unless value && !value.empty?
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                  env_name: "APPCENTER_APP_NAME",
+                               description: "App name. If there is no app with such name, you will be prompted to create one",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                UI.user_error!("No App name given, pass using `app_name: 'app name'`") unless value && !value.empty?
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                  env_name: "APPCENTER_DISTRIBUTE_APK",
+                               description: "Build release path for android build",
+                             default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                  optional: true,
+                                      type: String,
+                       conflicting_options: [:ipa],
+                            conflict_block: proc do |value|
+                              UI.user_error!("You can't use 'apk' and '#{value.key}' options in one run")
+                            end,
+                              verify_block: proc do |value|
+                                accepted_formats = [".apk"]
+                                UI.user_error!("Only \".apk\" formats are allowed, you provided \"#{File.extname(value)}\"") unless accepted_formats.include? File.extname(value)
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                  env_name: "APPCENTER_DISTRIBUTE_IPA",
+                               description: "Build release path for ios build",
+                             default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                  optional: true,
+                                      type: String,
+                       conflicting_options: [:apk],
+                            conflict_block: proc do |value|
+                              UI.user_error!("You can't use 'ipa' and '#{value.key}' options in one run")
+                            end,
+                              verify_block: proc do |value|
+                                accepted_formats = [".ipa"]
+                                UI.user_error!("Only \".ipa\" formats are allowed, you provided \"#{File.extname(value)}\"") unless accepted_formats.include? File.extname(value)
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :dsym,
+                                  env_name: "APPCENTER_DISTRIBUTE_DSYM",
+                               description: "Path to your symbols file. For iOS provide path to app.dSYM.zip",
+                             default_value: Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH],
+                                  optional: true,
+                                      type: String,
+                              verify_block: proc do |value|
+                                if value
+                                  UI.user_error!("Couldn't find dSYM file at path '#{value}'") unless File.exist?(value)
+                                end
+                              end),
+
+          FastlaneCore::ConfigItem.new(key: :upload_dsym_only,
+                                  env_name: "APPCENTER_DISTRIBUTE_UPLOAD_DSYM_ONLY",
+                               description: "Flag to upload only the dSYM file to App Center",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+
+          FastlaneCore::ConfigItem.new(key: :group,
+                                  env_name: "APPCENTER_DISTRIBUTE_GROUP",
+                               description: "Distribute group name",
+                             default_value: "Collaborators",
+                                  optional: true,
+                                      type: String),
+
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+                                  env_name: "APPCENTER_DISTRIBUTE_RELEASE_NOTES",
+                               description: "Release notes",
+                             default_value: Actions.lane_context[SharedValues::FL_CHANGELOG] || "No changelog given",
+                                  optional: true,
+                                      type: String)
+        ]
+      end
+
+      def self.output
+        [
+          ['APPCENTER_DOWNLOAD_LINK', 'The newly generated download link for this build'],
+          ['APPCENTER_BUILD_INFORMATION', 'contains all keys/values from the App Center API']
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'appcenter_upload(
+            api_token: "...",
+            owner_name: "appcenter_owner",
+            app_name: "testing_app",
+            apk: "./app-release.apk",
+            group: "Testers",
+            release_notes: "release notes"
+          )',
+          'appcenter_upload(
+            api_token: "...",
+            owner_name: "appcenter_owner",
+            app_name: "testing_app",
+            apk: "./app-release.ipa",
+            group: "Testers",
+            dsym: "./app.dSYM.zip",
+            release_notes: "release notes"
+          )'
+        ]
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb

@@ -0,0 +1,12 @@
+module Fastlane
+  module Helper
+    class AppcenterHelper
+      # class methods that you define here become available in your action
+      # as `Helper::AppcenterHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the appcenter plugin helper!")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Appcenter
+    VERSION = "0.1.4"
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-appcenter
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Microsoft Corporation
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-15 00:00:00.000000000 Z
+dependencies:
+- !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: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.29.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.29.0
+- !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: 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: 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: rubocop
+  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'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/appcenter.rb
+- lib/fastlane/plugin/appcenter/actions/appcenter_upload_action.rb
+- lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb
+- lib/fastlane/plugin/appcenter/version.rb
+homepage: https://github.com/Microsoft/fastlane-plugin-appcenter
+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.12
+signing_key: 
+specification_version: 4
+summary: Fastlane plugin for App Center
+test_files: []