fastlane 2.128.1 → 2.133.0

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,7 @@ module Fastlane
         build_number = params[:build_number]
         platform = params[:platform]
         output_directory = params[:output_directory]
+        wait_for_dsym_processing = params[:wait_for_dsym_processing]
         min_version = Gem::Version.new(params[:min_version]) if params[:min_version]
 
         # Set version if it is latest
@@ -85,14 +86,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) > (60 * 5)
+                  # 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
@@ -228,7 +247,14 @@ 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)
         ]
       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

@@ -16,7 +16,15 @@ module Fastlane
         project = get_project!(folder)
         target = get_target!(project, target_name)
         plist_file = get_plist!(folder, target, configuration)
-        version_number = get_version_number!(plist_file)
+        version_number = get_version_number_from_plist!(plist_file)
+
+        # Get from build 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)
+        # ${MARKETING_VERSION} also works
+        elsif version_number =~ /\$\{([\w\-]+)\}/
+          version_number = get_version_number_from_build_settings!(target, $1, configuration)
+        end
 
         # Store the number in the shared hash
         Actions.lane_context[SharedValues::VERSION_NUMBER] = version_number
@@ -65,6 +73,17 @@ module Fastlane
         target
       end
 
+      def self.get_version_number_from_build_settings!(target, variable, configuration = nil)
+        target.build_configurations.each do |config|
+          if configuration.nil? || config.name == configuration
+            value = config.build_settings[variable]
+            return value if value
+          end
+        end
+
+        UI.user_error!("Unable to find Xcode build setting: #{variable}")
+      end
+
       def self.get_plist!(folder, target, configuration = nil)
         plist_files = target.resolved_build_setting("INFOPLIST_FILE")
         plist_files_count = plist_files.values.compact.uniq.count
@@ -94,7 +113,7 @@ module Fastlane
         plist_file
       end
 
-      def self.get_version_number!(plist_file)
+      def self.get_version_number_from_plist!(plist_file)
         plist = Xcodeproj::Plist.read_from_path(plist_file)
         UI.user_error!("Unable to read plist: #{plist_file}") unless plist
 

data/fastlane/lib/fastlane/actions/github_api.rb

@@ -113,7 +113,7 @@ module Fastlane
                                          optional: true),
             FastlaneCore::ConfigItem.new(key: :raw_body,
                                          env_name: "FL_GITHUB_API_REQUEST_RAW_BODY",
-                                         description: "The request body taken vertabim instead of as JSON, useful for file uploads",
+                                         description: "The request body taken verbatim instead of as JSON, useful for file uploads",
                                          is_string: true,
                                          optional: true),
             FastlaneCore::ConfigItem.new(key: :path,

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?
@@ -102,7 +110,7 @@ module Fastlane
         [
           FastlaneCore::ConfigItem.new(key: :task,
                                        env_name: 'FL_GRADLE_TASK',
-                                       description: 'The gradle task you want to execute, e.g. `assemble` or `test`. For tasks such as `assembleMyFlavorRelease` you should use gradle(task: \'assemble\', flavor: \'Myflavor\', build_type: \'Release\')',
+                                       description: 'The gradle task you want to execute, e.g. `assemble`, `bundle` or `test`. For tasks such as `assembleMyFlavorRelease` you should use gradle(task: \'assemble\', flavor: \'Myflavor\', build_type: \'Release\')',
                                        optional: false,
                                        is_string: true),
           FastlaneCore::ConfigItem.new(key: :flavor,
@@ -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
 
@@ -187,8 +197,21 @@ module Fastlane
             task: "assemble",
             flavor: "WorldDomination",
             build_type: "Release"
-          )',
-          'gradle(
+          )
+          ```
+
+          To build an AAB use:
+          ```ruby
+          gradle(
+            task: "bundle",
+            flavor: "WorldDomination",
+            build_type: "Release"
+          )
+          ```
+
+          You can pass properties to gradle:
+          ```ruby
+          gradle(
             # ...
 
             properties: {
@@ -211,8 +234,11 @@ module Fastlane
               "android.injected.signing.key.alias" => "key_alias",
               "android.injected.signing.key.password" => "key_password",
             }
-          )',
-          '# If you need to pass sensitive information through the `gradle` action, and don\'t want the generated command to be printed before it is run, you can suppress that:
+          )
+          ```
+
+          If you need to pass sensitive information through the `gradle` action, and don\'t want the generated command to be printed before it is run, you can suppress that:
+          ```ruby
           gradle(
             # ...
             print_command: false
@@ -233,8 +259,11 @@ module Fastlane
             # ...
 
             flags: "--exitcode --xml file.xml"
-          )',
-          '# Delete the build directory and generated APKs
+          )
+          ```
+
+          Delete the build directory, generated APKs and AABs
+          ```ruby
           gradle(
             task: "clean"
           )'

data/fastlane/lib/fastlane/actions/import_from_git.rb

@@ -31,7 +31,7 @@ module Fastlane
                                        default_value: 'fastlane/Fastfile',
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :version,
-                                       description: "The version to checkout on the respository. Optimistic match operator or multiple conditions can be used to select the latest version within constraints",
+                                       description: "The version to checkout on the repository. Optimistic match operator or multiple conditions can be used to select the latest version within constraints",
                                        default_value: nil,
                                        is_string: false,
                                        optional: true)

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