fastlane 2.129.0 → 2.134.0

data/fastlane/lib/fastlane/actions/copy_artifacts.rb

@@ -16,7 +16,7 @@ module Fastlane
         # If any of the paths include "*", we assume that we are referring to the Unix entries
         # e.g /tmp/fastlane/* refers to all the files in /tmp/fastlane
         # We use Dir.glob to expand all those paths, this would create an array of arrays though, so flatten
-        artifacts = artifacts_to_search.map { |f| f.include?("*") ? Dir.glob(f) : f }.flatten
+        artifacts = artifacts_to_search.flat_map { |f| f.include?("*") ? Dir.glob(f) : f }
 
         UI.verbose("Copying artifacts #{artifacts.join(', ')} to #{target_path}")
         UI.verbose(params[:keep_original] ? "Keeping original files" : "Not keeping original files")

data/fastlane/lib/fastlane/actions/danger.rb

@@ -18,6 +18,7 @@ module Fastlane
         cmd << "--dangerfile=#{dangerfile}" if dangerfile
         cmd << "--fail-on-errors=true" if params[:fail_on_errors]
         cmd << "--new-comment" if params[:new_comment]
+        cmd << "--remove-previous-comments" if params[:remove_previous_comments]
         cmd << "--base=#{base}" if base
         cmd << "--head=#{head}" if head
         cmd << "pr #{pr}" if pr
@@ -78,6 +79,12 @@ module Fastlane
                                        is_string: false,
                                        optional: true,
                                        default_value: false),
+          FastlaneCore::ConfigItem.new(key: :remove_previous_comments,
+                                       env_name: "FL_DANGER_REMOVE_PREVIOUS_COMMENT",
+                                       description: "Makes Danger remove all previous comment and create a new one in the end of the list",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :base,
                                        env_name: "FL_DANGER_BASE",
                                        description: "A branch/tag/commit to use as the base of the diff. [master|dev|stable]",

data/fastlane/lib/fastlane/actions/deploygate.rb

@@ -33,7 +33,7 @@ module Fastlane
         options[:disable_notify] = 'yes' if options[:disable_notify]
 
         connection.post("/api/users/#{user_name}/apps", options)
-      rescue Faraday::Error::TimeoutError
+      rescue Faraday::TimeoutError
         UI.crash!("Timed out while uploading build. Check https://deploygate.com/ to see if the upload was completed.")
       end
 

data/fastlane/lib/fastlane/actions/docs/sync_code_signing.md

@@ -6,7 +6,7 @@
 
 A new approach to iOS code signing: Share one code signing identity across your development team to simplify your codesigning setup and prevent code signing issues.
 
-_match_ is the implementation of the [https://codesigning.guide concept](https://codesigning.guide). _match_ creates all required certificates & provisioning profiles and stores them in a separate git repository. Every team member with access to the repo can use those credentials for code signing. _match_ also automatically repairs broken and expired credentials. It's the easiest way to share signing credentials across teams
+_match_ is the implementation of the [codesigning.guide concept](https://codesigning.guide). _match_ creates all required certificates & provisioning profiles and stores them in a separate git repository. Every team member with access to the repo can use those credentials for code signing. _match_ also automatically repairs broken and expired credentials. It's the easiest way to share signing credentials across teams
 
 [More information on how to get started with codesigning](https://docs.fastlane.tools/codesigning/getting-started/)
 
@@ -79,7 +79,7 @@ You'll be asked if you want to store your code signing identities inside a **Git
 
 Use Git Storage to store all code signing identities in a private git repo, owned and operated by you. The files will be encrypted using OpenSSL.
 
-First, enter the URL to your private (!) Git repo (You can create one for free on e.g. [GitHub](https://github.com/new) or [BitBucket](https://bitbucket.org/repo/create)). The URL you enter can be either a `https://` or a `git` URL. (If your machine is currently using SSH to authenticate with GitHub, you'll want to use a `git` URL, otherwise you may see an authentication error when you attempt to use match.) `fastlane match init` won't read or modify your certificates or profiles yet, and also won't validate your git URL.
+First, enter the URL to your private (!) Git repo (You can create one for free on e.g. [GitHub](https://github.com/new) or [BitBucket](https://bitbucket.org/repo/create)). The URL you enter can be either a `https://` or a `git` URL. `fastlane match init` won't read or modify your certificates or profiles yet, and also won't validate your git URL.
 
 This will create a `Matchfile` in your current directory (or in your `./fastlane/` folder).
 
@@ -92,6 +92,25 @@ app_identifier("tools.fastlane.app")
 username("user@fastlane.tools")
 ```
 
+##### Git Storage on GitHub
+
+If your machine is currently using SSH to authenticate with GitHub, you'll want to use a `git` URL, otherwise, you may see an authentication error when you attempt to use match. Alternatively, you can set a basic authorization for _match_:
+
+Using parameter:
+
+```
+math(git_basic_authorization: '<YOUR KEY>')
+```
+
+Using environment variable:
+
+```
+ENV['MATCH_GIT_BASIC_AUTHORIZATION'] = '<YOUR KEY>'
+match
+```
+
+You can find more information about GitHub basic authentication and personal token generation here: [https://developer.github.com/v3/auth/#basic-authentication](https://developer.github.com/v3/auth/#basic-authentication)
+
 #### Google Cloud Storage
 
 Use [Google Cloud Storage](https://cloud.google.com/storage/) for a fully hosted solution for your code signing identities. Certificates are stored on Google Cloud, encrypted using Google managed keys. Everything will be stored on your Google account, inside a storage bucket you provide. You can also directly access the files using the web console.
@@ -119,7 +138,7 @@ match(git_branch: "team2", username: "user@team2.com")
 
 #### Google Cloud Storage
 
-If you use Google Cloud Storage, you don't need to do anything manually. Just use Google Cloud Storage, and the top level folder will be the team ID.
+If you use Google Cloud Storage, you don't need to do anything manually for multiple teams. Just use Google Cloud Storage, and the top level folder will be the team ID.
 
 ### Run
 
@@ -214,7 +233,7 @@ There are two cases for reading and writing certificates stored in a Google Clou
 1. Continuous integration jobs. These will authenticate to your Google Cloud project via a service account, and use a `gc_keys.json` file as credentials.
 1. Developers on a local workstation. In this case, you should choose whether everyone on your team will create their own `gc_keys.json` file, or whether you want to manage access to the bucket directly using your developers' Google accounts.
 
-When running `fastlane match init` the first time, the setup process will give you the option to create your `gc_keys.json` file. This file contains the auth credentials needed to access your Google Cloud storage bucket. Make sure to keep that file secret and never add it to version control. We recommend adding `gc_keys.json` to your `.gitignore`
+When running `fastlane match init` the first time, the setup process will give you the option to create your `gc_keys.json` file. This file contains the authentication credentials needed to access your Google Cloud storage bucket. Make sure to keep that file secret and never add it to version control. We recommend adding `gc_keys.json` to your `.gitignore`
 
 ##### Managing developer access via keys
 If you want to manage developer access to your certificates via authentication keys, every developer should create their own `gc_keys.json` and add the file to all their work machines. This will give the admin full control over who has read/write access to the given Storage bucket. At the same time it allows your team to revoke a single key if a file gets compromised.

data/fastlane/lib/fastlane/actions/download_dsyms.rb

@@ -25,6 +25,8 @@ module Fastlane
         build_number = params[:build_number]
         platform = params[:platform]
         output_directory = params[:output_directory]
+        wait_for_dsym_processing = params[:wait_for_dsym_processing]
+        wait_timeout = params[:wait_timeout]
         min_version = Gem::Version.new(params[:min_version]) if params[:min_version]
 
         # Set version if it is latest
@@ -44,6 +46,20 @@ module Fastlane
             version = latest_candidate_build.train_version
             build_number = latest_candidate_build.build_version
           end
+        elsif version == 'live'
+          UI.message("Looking for live version...")
+          live_version = app.live_version(platform: platform)
+
+          UI.user_error!("Could not find live version for your app, please try setting 'latest' or a specific version") if live_version.nil?
+
+          # No need to search for candidates, because released App Store version should only have one build
+          version = live_version.version
+          build_number = live_version.build_version
+        end
+
+        # Remove leading zeros from version string (eg. 1.02 -> 1.2)
+        if version
+          version = version.split(".").map(&:to_i).join(".")
         end
 
         # Make sure output_directory has a slash on the end
@@ -85,14 +101,32 @@ module Fastlane
               next
             end
 
-            begin
-              UI.verbose("Build_version: #{build.build_version} matches #{build_number}, grabbing dsym_url") if build_number
-
-              build_details = app.tunes_build_details(train: train.version_string, build_number: build.build_version, platform: platform)
-              download_url = build_details.dsym_url
-              UI.verbose("dsym_url: #{download_url}")
-            rescue Spaceship::TunesClient::ITunesConnectError => ex
-              UI.error("Error accessing dSYM file for build\n\n#{build}\n\nException: #{ex}")
+            UI.verbose("Build_version: #{build.build_version} matches #{build_number}, grabbing dsym_url") if build_number
+
+            start = Time.now
+            download_url = nil
+
+            loop do
+              begin
+                build_details = app.tunes_build_details(train: train.version_string, build_number: build.build_version, platform: platform)
+                download_url = build_details.dsym_url
+                UI.verbose("dsym_url: #{download_url}")
+              rescue Spaceship::TunesClient::ITunesConnectError => ex
+                UI.error("Error accessing dSYM file for build\n\n#{build}\n\nException: #{ex}")
+              end
+
+              unless download_url
+                if !wait_for_dsym_processing || (Time.now - start) > wait_timeout
+                  # In some cases, AppStoreConnect does not process the dSYMs, thus no error should be thrown.
+                  UI.message("Could not find any dSYM for #{build.build_version} (#{train.version_string})")
+                else
+                  UI.message("Waiting for dSYM file to appear...")
+                  sleep(30)
+                  next
+                end
+              end
+
+              break
             end
 
             if download_url
@@ -212,7 +246,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :version,
                                        short_option: "-v",
                                        env_name: "DOWNLOAD_DSYMS_VERSION",
-                                       description: "The app version for dSYMs you wish to download, pass in 'latest' to download only the latest build's dSYMs",
+                                       description: "The app version for dSYMs you wish to download, pass in 'latest' to download only the latest build's dSYMs or 'live' to download only the live verion dSYMs",
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :build_number,
                                        short_option: "-b",
@@ -228,7 +262,21 @@ module Fastlane
                                        short_option: "-s",
                                        env_name: "DOWNLOAD_DSYMS_OUTPUT_DIRECTORY",
                                        description: "Where to save the download dSYMs, defaults to the current path",
-                                       optional: true)
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :wait_for_dsym_processing,
+                                       short_option: "-w",
+                                       env_name: "DOWNLOAD_DSYMS_WAIT_FOR_DSYM_PROCESSING",
+                                       description: "Wait for dSYMs to process",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :wait_timeout,
+                                       short_option: "-t",
+                                       env_name: "DOWNLOAD_DSYMS_WAIT_TIMEOUT",
+                                       description: "Number of seconds to wait for dSYMs to process",
+                                       optional: true,
+                                       default_value: 300,
+                                       type: Integer)
         ]
       end
 
@@ -254,6 +302,7 @@ module Fastlane
         [
           'download_dsyms',
           'download_dsyms(version: "1.0.0", build_number: "345")',
+          'download_dsyms(version: "live")',
           'download_dsyms(min_version: "1.2.3")'
         ]
       end

data/fastlane/lib/fastlane/actions/ensure_env_vars.rb

@@ -0,0 +1,58 @@
+module Fastlane
+  module Actions
+    class EnsureEnvVarsAction < Action
+      def self.run(params)
+        variables = params[:env_vars]
+
+        variables.each do |variable|
+          next unless ENV[variable].to_s.strip.empty?
+
+          UI.user_error!("Missing environment variable '#{variable}'")
+        end
+
+        is_one = variables.length == 1
+
+        UI.success("Environment variable#{is_one ? '' : 's'} '#{variables.join('\', \'')}' #{is_one ? 'is' : 'are'} set!")
+      end
+
+      def self.description
+        'Raises an exception if the specified env vars are not set'
+      end
+
+      def self.details
+        'This action will check if some environment variables are set.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :env_vars,
+                                       description: 'The environment variables names that should be checked',
+                                       type: Array,
+                                       verify_block: proc do |value|
+                                         UI.user_error!('Specify at least one environment variable name') if value.empty?
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ['revolter']
+      end
+
+      def self.example_code
+        [
+          'ensure_env_vars(
+            env_vars: [\'GITHUB_USER_NAME\', \'GITHUB_API_TOKEN\']
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_version_number.rb

@@ -18,9 +18,18 @@ module Fastlane
         plist_file = get_plist!(folder, target, configuration)
         version_number = get_version_number_from_plist!(plist_file)
 
-        # Get from build settings if needed (ex: $(MARKETING_VERSION) is default in Xcode 11)
+        # Get from build settings (or project settings) if needed (ex: $(MARKETING_VERSION) is default in Xcode 11)
         if version_number =~ /\$\(([\w\-]+)\)/
-          version_number = get_version_number_from_build_settings!(target, $1, configuration)
+          version_number = get_version_number_from_build_settings!(target, $1, configuration) || get_version_number_from_build_settings!(project, $1, configuration)
+
+        # ${MARKETING_VERSION} also works
+        elsif version_number =~ /\$\{([\w\-]+)\}/
+          version_number = get_version_number_from_build_settings!(target, $1, configuration) || get_version_number_from_build_settings!(project, $1, configuration)
+        end
+
+        # Error out if version_number is not set
+        if version_number.nil?
+          UI.user_error!("Unable to find Xcode build setting: #{$1}")
         end
 
         # Store the number in the shared hash
@@ -78,7 +87,7 @@ module Fastlane
           end
         end
 
-        UI.user_error!("Unable to find Xcode build setting: #{variable}")
+        return nil
       end
 
       def self.get_plist!(folder, target, configuration = nil)

data/fastlane/lib/fastlane/actions/gradle.rb

@@ -8,6 +8,8 @@ module Fastlane
       GRADLE_ALL_APK_OUTPUT_PATHS = :GRADLE_ALL_APK_OUTPUT_PATHS
       GRADLE_AAB_OUTPUT_PATH = :GRADLE_AAB_OUTPUT_PATH
       GRADLE_ALL_AAB_OUTPUT_PATHS = :GRADLE_ALL_AAB_OUTPUT_PATHS
+      GRADLE_OUTPUT_JSON_OUTPUT_PATH = :GRADLE_OUTPUT_JSON_OUTPUT_PATH
+      GRADLE_ALL_OUTPUT_JSON_OUTPUT_PATHS = :GRADLE_ALL_OUTPUT_JSON_OUTPUT_PATHS
       GRADLE_FLAVOR = :GRADLE_FLAVOR
       GRADLE_BUILD_TYPE = :GRADLE_BUILD_TYPE
     end
@@ -60,6 +62,7 @@ module Fastlane
 
         apk_search_path = File.join(project_dir, '**', 'build', 'outputs', 'apk', '**', '*.apk')
         aab_search_path = File.join(project_dir, '**', 'build', 'outputs', 'bundle', '**', '*.aab')
+        output_json_search_path = File.join(project_dir, '**', 'build', 'outputs', 'apk', '**', 'output.json')
 
         # Our apk/aab is now built, but there might actually be multiple ones that were built if a flavor was not specified in a multi-flavor project (e.g. `assembleRelease`)
         # However, we're not interested in unaligned apk's...
@@ -67,18 +70,23 @@ module Fastlane
         new_apks = new_apks.map { |path| File.expand_path(path) }
         new_aabs = Dir[aab_search_path]
         new_aabs = new_aabs.map { |path| File.expand_path(path) }
+        new_output_jsons = Dir[output_json_search_path]
+        new_output_jsons = new_output_jsons.map { |path| File.expand_path(path) }
 
         # We expose all of these new apks and aabs
         Actions.lane_context[SharedValues::GRADLE_ALL_APK_OUTPUT_PATHS] = new_apks
         Actions.lane_context[SharedValues::GRADLE_ALL_AAB_OUTPUT_PATHS] = new_aabs
+        Actions.lane_context[SharedValues::GRADLE_ALL_OUTPUT_JSON_OUTPUT_PATHS] = new_output_jsons
 
         # We also take the most recent apk and aab to return as SharedValues::GRADLE_APK_OUTPUT_PATH and SharedValues::GRADLE_AAB_OUTPUT_PATH
         # This is the one that will be relevant for most projects that just build a single build variant (flavor + build type combo).
         # In multi build variants this value is undefined
         last_apk_path = new_apks.sort_by(&File.method(:mtime)).last
         last_aab_path = new_aabs.sort_by(&File.method(:mtime)).last
+        last_output_json_path = new_output_jsons.sort_by(&File.method(:mtime)).last
         Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH] = File.expand_path(last_apk_path) if last_apk_path
         Actions.lane_context[SharedValues::GRADLE_AAB_OUTPUT_PATH] = File.expand_path(last_aab_path) if last_aab_path
+        Actions.lane_context[SharedValues::GRADLE_OUTPUT_JSON_OUTPUT_PATH] = File.expand_path(last_output_json_path) if last_output_json_path
 
         # Give a helpful message in case there were no new apks or aabs. Remember we're only running this code when assembling, in which case we certainly expect there to be an apk or aab
         UI.message('Couldn\'t find any new signed apk files...') if new_apks.empty? && new_aabs.empty?
@@ -165,7 +173,9 @@ module Fastlane
           ['GRADLE_FLAVOR', 'The flavor, e.g. `MyFlavor`'],
           ['GRADLE_BUILD_TYPE', 'The build type, e.g. `Release`'],
           ['GRADLE_AAB_OUTPUT_PATH', 'The path to the most recent Android app bundle'],
-          ['GRADLE_ALL_AAB_OUTPUT_PATHS', 'The paths to the most recent Android app bundles']
+          ['GRADLE_ALL_AAB_OUTPUT_PATHS', 'The paths to the most recent Android app bundles'],
+          ['GRADLE_OUTPUT_JSON_OUTPUT_PATH', 'The path to the most recent output.json file'],
+          ['GRADLE_ALL_OUTPUT_JSON_OUTPUT_PATHS', 'The path to the newly generated output.json files']
         ]
       end
 

data/fastlane/lib/fastlane/actions/onesignal.rb

@@ -11,15 +11,26 @@ module Fastlane
         require 'uri'
         require 'base64'
 
-        UI.message("Parameter App name: #{params[:app_name]}")
+        app_id = params[:app_id].to_s.strip
         auth_token = params[:auth_token]
-        app_name = params[:app_name]
+        app_name = params[:app_name].to_s
         apns_p12_password = params[:apns_p12_password]
         android_token = params[:android_token]
         android_gcm_sender_id = params[:android_gcm_sender_id]
 
+        has_app_id = !app_id.empty?
+        has_app_name = !app_name.empty?
+
+        is_update = has_app_id
+
+        UI.user_error!('Please specify the `app_id` or the `app_name` parameters!') if !has_app_id && !has_app_name
+
+        UI.message("Parameter App ID: #{app_id}") if has_app_id
+        UI.message("Parameter App name: #{app_name}") if has_app_name
+
         payload = {}
-        payload['name'] = app_name
+
+        payload['name'] = app_name if has_app_name
 
         unless params[:apns_p12].nil?
           data = File.read(params[:apns_p12])
@@ -33,61 +44,70 @@ module Fastlane
         payload["gcm_key"] = android_token unless android_token.nil?
         payload["android_gcm_sender_id"] = android_gcm_sender_id unless android_gcm_sender_id.nil?
 
-        # here's the actual lifting - POST to OneSignal
+        # here's the actual lifting - POST or PUT to OneSignal
 
         json_headers = { 'Content-Type' => 'application/json', 'Authorization' => "Basic #{auth_token}" }
-        uri = URI.parse('https://onesignal.com/api/v1/apps')
+        url = +'https://onesignal.com/api/v1/apps'
+        url << '/' + app_id if is_update
+        uri = URI.parse(url)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
-        response = http.post(uri.path, payload.to_json, json_headers)
+
+        if is_update
+          response = http.put(uri.path, payload.to_json, json_headers)
+        else
+          response = http.post(uri.path, payload.to_json, json_headers)
+        end
+
         response_body = JSON.parse(response.body)
 
         Actions.lane_context[SharedValues::ONE_SIGNAL_APP_ID] = response_body["id"]
         Actions.lane_context[SharedValues::ONE_SIGNAL_APP_AUTH_KEY] = response_body["basic_auth_key"]
 
-        check_response_code(response)
+        check_response_code(response, is_update)
       end
 
-      def self.check_response_code(response)
+      def self.check_response_code(response, is_update)
         case response.code.to_i
         when 200, 204
-          puts("Successfully created new OneSignal app".green)
+          UI.success("Successfully #{is_update ? 'updated' : 'created new'} OneSignal app")
         else
           UI.user_error!("Unexpected #{response.code} with response: #{response.body}")
         end
       end
 
       def self.description
-        "Create a new [OneSignal](https://onesignal.com/) application"
+        "Create or update a new [OneSignal](https://onesignal.com/) application"
       end
 
       def self.details
-        "You can use this action to automatically create a OneSignal application. You can also upload a `.p12` with password, a GCM key, or both."
+        "You can use this action to automatically create or update a OneSignal application. You can also upload a `.p12` with password, a GCM key, or both."
       end
 
       def self.available_options
         [
-          FastlaneCore::ConfigItem.new(key: :auth_token,
-                                      env_name: "ONE_SIGNAL_AUTH_KEY",
-                                      sensitive: true,
-                                      description: "OneSignal Authorization Key",
-                                      verify_block: proc do |value|
-                                        unless value.to_s.length > 0
-                                          UI.error("Please add 'ENV[\"ONE_SIGNAL_AUTH_KEY\"] = \"your token\"' to your Fastfile's `before_all` section.")
-                                          UI.user_error!("No ONE_SIGNAL_AUTH_KEY given.")
-                                        end
-                                      end),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       env_name: "ONE_SIGNAL_APP_ID",
+                                       sensitive: true,
+                                       description: "OneSignal App ID. Setting this updates an existing app",
+                                       optional: true),
 
-          FastlaneCore::ConfigItem.new(key: :app_name,
-                                       env_name: "ONE_SIGNAL_APP_NAME",
-                                       description: "OneSignal App Name",
+          FastlaneCore::ConfigItem.new(key: :auth_token,
+                                       env_name: "ONE_SIGNAL_AUTH_KEY",
+                                       sensitive: true,
+                                       description: "OneSignal Authorization Key",
                                        verify_block: proc do |value|
-                                         unless value.to_s.length > 0
-                                           UI.error("Please add 'ENV[\"ONE_SIGNAL_APP_NAME\"] = \"Your app name\"' to your Fastfile's `before_all` section.")
-                                           UI.user_error!("No ONE_SIGNAL_APP_NAME given.")
+                                         if value.to_s.empty?
+                                           UI.error("Please add 'ENV[\"ONE_SIGNAL_AUTH_KEY\"] = \"your token\"' to your Fastfile's `before_all` section.")
+                                           UI.user_error!("No ONE_SIGNAL_AUTH_KEY given.")
                                          end
                                        end),
 
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                       env_name: "ONE_SIGNAL_APP_NAME",
+                                       description: "OneSignal App Name. This is required when creating an app (in other words, when `:app_id` is not set, and optional when updating an app",
+                                       optional: true),
+
           FastlaneCore::ConfigItem.new(key: :android_token,
                                        env_name: "ANDROID_TOKEN",
                                        description: "ANDROID GCM KEY",
@@ -121,8 +141,8 @@ module Fastlane
 
       def self.output
         [
-          ['ONE_SIGNAL_APP_ID', 'The OneSignal app ID of the newly created app'],
-          ['ONE_SIGNAL_APP_AUTH_KEY', 'The auth token for the newly created OneSignal app']
+          ['ONE_SIGNAL_APP_ID', 'The app ID of the newly created or updated app'],
+          ['ONE_SIGNAL_APP_AUTH_KEY', 'The auth token for the newly created or updated app']
         ]
       end
 
@@ -144,6 +164,16 @@ module Fastlane
             apns_p12: "Path to Apple .p12 file (optional)",
             apns_p12_password: "Password for .p12 file (optional)",
             apns_env: "production/sandbox (defaults to production)"
+          )',
+          'onesignal(
+            app_id: "Your OneSignal App ID",
+            auth_token: "Your OneSignal Auth Token",
+            app_name: "New Name for OneSignal App",
+            android_token: "Your Android GCM key (optional)",
+            android_gcm_sender_id: "Your Android GCM Sender ID (optional)",
+            apns_p12: "Path to Apple .p12 file (optional)",
+            apns_p12_password: "Password for .p12 file (optional)",
+            apns_env: "production/sandbox (defaults to production)"
           )'
         ]
       end