fastlane 2.135.2 → 2.140.0

data/fastlane/lib/fastlane/actions/ensure_bundle_exec.rb

@@ -10,7 +10,7 @@ module Fastlane
         if FastlaneCore::Helper.bundler?
           UI.success("Using bundled fastlane ✅")
         else
-          UI.user_error!("fastlane detected a Gemfile in the current directory. However it seems like you don't use `bundle exec`. Use `bundle exec fastlane #{ARGV.join(' ')}`")
+          UI.user_error!("fastlane detected a Gemfile in the current directory. However, it seems like you didn't use `bundle exec`. Use `bundle exec fastlane #{ARGV.join(' ')}` instead.")
         end
       end
 
@@ -24,8 +24,8 @@ module Fastlane
 
       def self.details
         [
-          "This action will check if you are using bundle exec to run fastlane.",
-          "You can put it into `before_all` and make sure that fastlane is run using `bundle exec fastlane` command."
+          "This action will check if you are using `bundle exec` to run fastlane.",
+          "You can put it into `before_all` to make sure that fastlane is ran using the `bundle exec fastlane` command."
         ].join("\n")
       end
 

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

@@ -91,7 +91,7 @@ module Fastlane
       end
 
       def self.get_plist!(folder, target, configuration = nil)
-        plist_files = target.resolved_build_setting("INFOPLIST_FILE")
+        plist_files = target.resolved_build_setting("INFOPLIST_FILE", true)
         plist_files_count = plist_files.values.compact.uniq.count
 
         # Get plist file for specified configuration
@@ -113,7 +113,12 @@ module Fastlane
           plist_file.gsub!("$(SRCROOT)/", "")
         end
 
-        plist_file = File.absolute_path(File.join(folder, plist_file))
+        # plist_file can be `Relative` or `Absolute` path.
+        # Make to `Absolute` path when plist_file is `Relative` path
+        unless File.exist?(plist_file)
+          plist_file = File.absolute_path(File.join(folder, plist_file))
+        end
+
         UI.user_error!("Cannot find plist file: #{plist_file}") unless File.exist?(plist_file)
 
         plist_file

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

@@ -10,17 +10,23 @@ module Fastlane
       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_MAPPING_TXT_OUTPUT_PATH = :GRADLE_MAPPING_TXT_OUTPUT_PATH
+      GRADLE_ALL_MAPPING_TXT_OUTPUT_PATHS = :GRADLE_ALL_MAPPING_TXT_OUTPUT_PATHS
       GRADLE_FLAVOR = :GRADLE_FLAVOR
       GRADLE_BUILD_TYPE = :GRADLE_BUILD_TYPE
     end
 
     class GradleAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.run(params)
         task = params[:task]
         flavor = params[:flavor]
         build_type = params[:build_type]
+        tasks = params[:tasks]
 
-        gradle_task = [task, flavor, build_type].join
+        gradle_task = gradle_task(task, flavor, build_type, tasks)
+
+        UI.user_error!('Please pass a gradle task or tasks') if gradle_task.empty?
 
         project_dir = params[:project_dir]
 
@@ -63,6 +69,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')
+        mapping_txt_search_path = File.join(project_dir, '**', 'build', 'outputs', 'mapping', '**', 'mapping.txt')
 
         # 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...
@@ -72,11 +79,14 @@ module Fastlane
         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) }
+        new_mapping_txts = Dir[mapping_txt_search_path]
+        new_mapping_txts = new_mapping_txts.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
+        Actions.lane_context[SharedValues::GRADLE_ALL_MAPPING_TXT_OUTPUT_PATHS] = new_mapping_txts
 
         # 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).
@@ -84,15 +94,39 @@ module Fastlane
         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
+        last_mapping_txt_path = new_mapping_txts.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
+        Actions.lane_context[SharedValues::GRADLE_MAPPING_TXT_OUTPUT_PATH] = File.expand_path(last_mapping_txt_path) if last_mapping_txt_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?
 
         return result
       end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.gradle_task(task, flavor, build_type, tasks)
+        gradle_task = [task, flavor, build_type].join
+
+        if gradle_task.empty? && !tasks.nil?
+          gradle_task = tasks.join(' ')
+        end
+
+        gradle_task
+      end
+
+      def self.step_text(params)
+        task = params[:task]
+        flavor = params[:flavor]
+        build_type = params[:build_type]
+        tasks = params[:tasks]
+
+        gradle_task = gradle_task(task, flavor, build_type, tasks)
+
+        return gradle_task
+      end
 
       #####################################################
       # @!group Documentation
@@ -111,7 +145,8 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :task,
                                        env_name: 'FL_GRADLE_TASK',
                                        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,
+                                       conflicting_options: [:tasks],
+                                       optional: true,
                                        is_string: true),
           FastlaneCore::ConfigItem.new(key: :flavor,
                                        env_name: 'FL_GRADLE_FLAVOR',
@@ -123,6 +158,13 @@ module Fastlane
                                        description: 'The build type that you want the task for, e.g. `Release`. Useful for some tasks such as `assemble`',
                                        optional: true,
                                        is_string: true),
+          FastlaneCore::ConfigItem.new(key: :tasks,
+                                       type: Array,
+                                       env_name: 'FL_GRADLE_TASKS',
+                                       description: 'The multiple gradle tasks that you want to execute, e.g. `[assembleDebug, bundleDebug]`',
+                                       conflicting_options: [:task],
+                                       optional: true,
+                                       is_string: false),
           FastlaneCore::ConfigItem.new(key: :flags,
                                        env_name: 'FL_GRADLE_FLAGS',
                                        description: 'All parameter flags you want to pass to the gradle command, e.g. `--exitcode --xml file.xml`',
@@ -175,7 +217,9 @@ module Fastlane
           ['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_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']
+          ['GRADLE_ALL_OUTPUT_JSON_OUTPUT_PATHS', 'The path to the newly generated output.json files'],
+          ['GRADLE_MAPPING_TXT_OUTPUT_PATH', 'The path to the most recent mapping.txt file'],
+          ['GRADLE_ALL_MAPPING_TXT_OUTPUT_PATHS', 'The path to the newly generated mapping.txt files']
         ]
       end
 
@@ -209,6 +253,13 @@ module Fastlane
           )
           ```
 
+          You can pass multiple gradle tasks:
+          ```ruby
+          gradle(
+            tasks: ["assembleDebug", "bundleDebug"]
+          )
+          ```
+
           You can pass properties to gradle:
           ```ruby
           gradle(

data/fastlane/lib/fastlane/actions/increment_version_number.rb

@@ -43,6 +43,9 @@ module Fastlane
           version_array = current_version.split(".").map(&:to_i)
 
           case params[:bump_type]
+          when "bump"
+            version_array[-1] = version_array[-1] + 1
+            next_version_number = version_array.join(".")
           when "patch"
             UI.user_error!(version_token_error) if version_array.count < 3
             version_array[2] = version_array[2] + 1
@@ -109,9 +112,9 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :bump_type,
                                        env_name: "FL_VERSION_NUMBER_BUMP_TYPE",
                                        description: "The type of this version bump. Available: patch, minor, major",
-                                       default_value: "patch",
+                                       default_value: "bump",
                                        verify_block: proc do |value|
-                                         UI.user_error!("Available values are 'patch', 'minor' and 'major'") unless ['patch', 'minor', 'major'].include?(value)
+                                         UI.user_error!("Available values are 'patch', 'minor' and 'major'") unless ['bump', 'patch', 'minor', 'major'].include?(value)
                                        end),
           FastlaneCore::ConfigItem.new(key: :version_number,
                                        env_name: "FL_VERSION_NUMBER_VERSION_NUMBER",
@@ -148,7 +151,7 @@ module Fastlane
 
       def self.example_code
         [
-          'increment_version_number # Automatically increment patch version number',
+          'increment_version_number # Automatically increment version number',
           'increment_version_number(
             bump_type: "patch" # Automatically increment patch version number
           )',

data/fastlane/lib/fastlane/actions/last_git_tag.rb

@@ -2,7 +2,7 @@ module Fastlane
   module Actions
     class LastGitTagAction < Action
       def self.run(params)
-        Actions.last_git_tag_name
+        Actions.last_git_tag_name(true, params[:pattern])
       end
 
       #####################################################
@@ -14,7 +14,12 @@ module Fastlane
       end
 
       def self.available_options
-        []
+        [
+          FastlaneCore::ConfigItem.new(key: :pattern,
+                                       description: "Pattern to filter tags when looking for last one. Limit tags to ones matching given shell glob. If pattern lacks ?, *, or [, * at the end is implied",
+                                       default_value: nil,
+                                       optional: true)
+        ]
       end
 
       def self.output
@@ -26,7 +31,7 @@ module Fastlane
       end
 
       def self.authors
-        ["KrauseFx"]
+        ["KrauseFx", "wedkarz"]
       end
 
       def self.is_supported?(platform)
@@ -34,12 +39,16 @@ module Fastlane
       end
 
       def self.details
-        "If you are using this action on a **shallow clone**, *the default with some CI systems like Bamboo*, you need to ensure that you have also pulled all the git tags appropriately. Assuming your git repo has the correct remote set you can issue `sh('git fetch --tags')`."
+        [
+          "If you are using this action on a **shallow clone**, *the default with some CI systems like Bamboo*, you need to ensure that you have also pulled all the git tags appropriately. Assuming your git repo has the correct remote set you can issue `sh('git fetch --tags')`.",
+          "Pattern parameter allows you to filter to a subset of tags."
+        ].join("\n")
       end
 
       def self.example_code
         [
-          'last_git_tag'
+          'last_git_tag',
+          'last_git_tag(pattern: "release/v1.0/")'
         ]
       end
 

data/fastlane/lib/fastlane/actions/latest_testflight_build_number.rb

@@ -64,7 +64,7 @@ module Fastlane
                                        is_string: true,
                                        default_value: "ios",
                                        verify_block: proc do |value|
-                                         UI.user_error!("The platform can only be ios, or appletvos") unless %('ios', 'appletvos').include?(value)
+                                         UI.user_error!("The platform can only be ios, osx, or appletvos") unless %('osx', ios', 'appletvos').include?(value)
                                        end),
           FastlaneCore::ConfigItem.new(key: :initial_build_number,
                                        env_name: "INITIAL_BUILD_NUMBER",
@@ -110,7 +110,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        platform == :ios
+        [:ios, :mac].include?(platform)
       end
 
       def self.example_code

data/fastlane/lib/fastlane/actions/register_devices.rb

@@ -25,7 +25,11 @@ module Fastlane
           end
 
           new_devices = devices_file.drop(1).map do |row|
-            UI.user_error!("Invalid device line, please provide a file according to the Apple Sample UDID file (https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip)") unless (2..3).cover?(row.count)
+            if row.count == 1
+              UI.user_error!("Invalid device line, ensure you are using tabs (NOT spaces). See Apple's sample/spec here: https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip")
+            elsif !(2..3).cover?(row.count)
+              UI.user_error!("Invalid device line, please provide a file according to the Apple Sample UDID file (https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip)")
+            end
             row
           end
         else

data/fastlane/lib/fastlane/actions/ruby_version.rb

@@ -40,7 +40,7 @@ module Fastlane
       def self.details
         [
           "Add this to your `Fastfile` to require a certain version of _ruby_.",
-          "Put it at the top of your `Fastfile to ensure that _fastlane_ is executed appropriately."
+          "Put it at the top of your `Fastfile` to ensure that _fastlane_ is executed appropriately."
         ].join("\n")
       end
 

data/fastlane/lib/fastlane/actions/run_tests.rb

@@ -10,17 +10,10 @@ module Fastlane
     class RunTestsAction < Action
       def self.run(values)
         require 'scan'
-        plist_files_before = []
+        manager = Scan::Manager.new
 
         begin
-          destination = values[:destination] # save destination value which can be later overridden
-          Scan.config = values # we set this here to auto-detect missing values, which we need later on
-          unless values[:derived_data_path].to_s.empty?
-            plist_files_before = test_summary_filenames(values[:derived_data_path])
-          end
-
-          values[:destination] = destination # restore destination value
-          Scan::Manager.new.work(values)
+          manager.work(values)
 
           zip_build_products_path = Scan.cache[:zip_build_products_path]
           Actions.lane_context[SharedValues::SCAN_ZIP_BUILD_PRODUCTS_PATH] = zip_build_products_path if zip_build_products_path
@@ -37,8 +30,10 @@ module Fastlane
           end
         ensure
           unless values[:derived_data_path].to_s.empty?
+            plist_files_before = manager.plist_files_before || []
+
             Actions.lane_context[SharedValues::SCAN_DERIVED_DATA_PATH] = values[:derived_data_path]
-            plist_files_after = test_summary_filenames(values[:derived_data_path])
+            plist_files_after = manager.test_summary_filenames(values[:derived_data_path])
             all_test_summaries = (plist_files_after - plist_files_before)
             Actions.lane_context[SharedValues::SCAN_GENERATED_PLIST_FILES] = all_test_summaries
             Actions.lane_context[SharedValues::SCAN_GENERATED_PLIST_FILE] = all_test_summaries.last
@@ -85,18 +80,6 @@ module Fastlane
 
       private_class_method
 
-      def self.test_summary_filenames(derived_data_path)
-        files = []
-
-        # Xcode < 10
-        files += Dir["#{derived_data_path}/**/Logs/Test/*TestSummaries.plist"]
-
-        # Xcode 10
-        files += Dir["#{derived_data_path}/**/Logs/Test/*.xcresult/TestSummaries.plist"]
-
-        return files
-      end
-
       def self.example_code
         [
           'run_tests',

data/fastlane/lib/fastlane/actions/setup_ci.rb

@@ -7,19 +7,22 @@ module Fastlane
           return
         end
 
-        case params[:provider]
-        when 'travis'
-          setup_keychain
+        case detect_provider(params)
         when 'circleci'
-          setup_keychain
           setup_output_paths
         end
+
+        setup_keychain
       end
 
       def self.should_run?(params)
         Helper.ci? || params[:force]
       end
 
+      def self.detect_provider(params)
+        params[:provider] || (Helper.is_circle_ci? ? 'circleci' : nil)
+      end
+
       def self.setup_keychain
         unless ENV["MATCH_KEYCHAIN_NAME"].nil?
           UI.message("Skipping Keychain setup as a keychain was already specified")
@@ -37,7 +40,8 @@ module Fastlane
           unlock: true,
           timeout: 3600,
           lock_when_sleeps: true,
-          password: ""
+          password: "",
+          add_to_search_list: true
         )
 
         UI.message("Enabling match readonly mode.")
@@ -87,18 +91,20 @@ module Fastlane
                                        default_value: false),
           FastlaneCore::ConfigItem.new(key: :provider,
                                        env_name: "FL_SETUP_CI_PROVIDER",
-                                       description: "CI provider",
+                                       description: "CI provider. If none is set, the provider is detected automatically",
                                        is_string: true,
                                        default_value: false,
                                        verify_block: proc do |value|
                                          value = value.to_s
+                                         # Validate both 'travis' and 'circleci' for backwards compatibility, even
+                                         # though only the latter receives special treatment by this action
                                          UI.user_error!("A given CI provider '#{value}' is not supported. Available CI providers: 'travis', 'circleci'") unless ["travis", "circleci"].include?(value)
                                        end)
         ]
       end
 
       def self.authors
-        ["mollyIV"]
+        ["mollyIV", "svenmuennich"]
       end
 
       def self.is_supported?(platform)
@@ -108,7 +114,7 @@ module Fastlane
       def self.example_code
         [
           'setup_ci(
-            provider: "travis"
+            provider: "circleci"
           )'
         ]
       end

data/fastlane/lib/fastlane/actions/testfairy.rb

@@ -92,6 +92,8 @@ module Fastlane
             [key, value]
           when :options
             [key, options_to_client.call(value).join(',')]
+          when :custom
+            [key, value]
           else
             UI.user_error!("Unknown parameter: #{key}")
           end
@@ -223,6 +225,11 @@ module Fastlane
                                        env_name: "FL_TESTFAIRY_OPTIONS",
                                        description: "Array of options (shake,video_only_wifi,anonymous)",
                                        default_value: []),
+          FastlaneCore::ConfigItem.new(key: :custom,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_CUSTOM",
+                                       description: "Array of custom options. Contact support@testfairy.com for more information",
+                                       default_value: ''),
           FastlaneCore::ConfigItem.new(key: :timeout,
                                        env_name: "FL_TESTFAIRY_TIMEOUT",
                                        description: "Request timeout in seconds",
@@ -252,7 +259,7 @@ module Fastlane
       end
 
       def self.authors
-        ["taka0125", "tcurdt"]
+        ["taka0125", "tcurdt", "vijaysharm"]
       end
 
       def self.is_supported?(platform)

data/fastlane/lib/fastlane/actions/upload_to_play_store_internal_app_sharing.rb

@@ -0,0 +1,78 @@
+module Fastlane
+  module Actions
+    class UploadToPlayStoreInternalAppSharingAction < Action
+      def self.run(params)
+        require 'supply'
+
+        # If no APK params were provided, try to fill in the values from lane context, preferring
+        # the multiple APKs over the single APK if set.
+        if params[:apk_paths].nil? && params[:apk].nil?
+          all_apk_paths = Actions.lane_context[SharedValues::GRADLE_ALL_APK_OUTPUT_PATHS] || []
+          if all_apk_paths.size > 1
+            params[:apk_paths] = all_apk_paths
+          else
+            params[:apk] = Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH]
+          end
+        end
+
+        # If no AAB param was provided, try to fill in the value from lane context.
+        # First GRADLE_ALL_AAB_OUTPUT_PATHS if only one
+        # Else from GRADLE_AAB_OUTPUT_PATH
+        if params[:aab].nil?
+          all_aab_paths = Actions.lane_context[SharedValues::GRADLE_ALL_AAB_OUTPUT_PATHS] || []
+          if all_aab_paths.count == 1
+            params[:aab] = all_aab_paths.first
+          else
+            params[:aab] = Actions.lane_context[SharedValues::GRADLE_AAB_OUTPUT_PATH]
+          end
+        end
+
+        Supply.config = params # we already have the finished config
+
+        Supply::Uploader.new.perform_upload_to_internal_app_sharing
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload binaries to Google Play Internal App Sharing (via _supply_)"
+      end
+
+      def self.details
+        "More information: https://docs.fastlane.tools/actions/upload_to_play_store_internal_app_sharing/"
+      end
+
+      def self.available_options
+        require 'supply'
+        require 'supply/options'
+        options = Supply::Options.available_options.clone
+
+        # remove all the unnecessary (for this action) options
+        options_to_keep = [:package_name, :apk, :apk_paths, :aab, :aab_paths, :json_key, :json_key_data, :root_url, :timeout]
+        options.delete_if { |option| options_to_keep.include?(option.key) == false }
+      end
+
+      def self.return_value
+        "Returns a string containing the download URL for the uploaded APK/AAB (or array of strings if multiple were uploaded)."
+      end
+
+      def self.authors
+        ["andrewhavens"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        ["upload_to_play_store_internal_app_sharing"]
+      end
+
+      def self.category
+        :production
+      end
+    end
+  end
+end