fastlane 2.133.0 → 2.136.0

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

@@ -26,6 +26,7 @@ module Fastlane
         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
@@ -45,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
@@ -101,7 +116,7 @@ module Fastlane
               end
 
               unless download_url
-                if !wait_for_dsym_processing || (Time.now - start) > (60 * 5)
+                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
@@ -231,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 version dSYMs",
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :build_number,
                                        short_option: "-b",
@@ -254,7 +269,14 @@ module Fastlane
                                        description: "Wait for dSYMs to process",
                                        optional: true,
                                        default_value: false,
-                                       type: Boolean)
+                                       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
 
@@ -280,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/download_from_play_store.rb

@@ -29,7 +29,7 @@ module Fastlane
         options = Supply::Options.available_options.clone
 
         # remove all the unnecessary (for this action) options
-        options_to_keep = [:package_name, :metadata_path, :json_key, :json_key_data, :root_url, :timeout, :key, :issuer]
+        options_to_keep = [:package_name, :version_name, :track, :metadata_path, :json_key, :json_key_data, :root_url, :timeout, :key, :issuer]
         options.delete_if { |option| options_to_keep.include?(option.key) == false }
       end
 

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

@@ -18,12 +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)
+          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
@@ -81,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/google_play_track_version_codes.rb

@@ -20,7 +20,11 @@ module Fastlane
 
         Supply.config = params
 
-        Supply::Reader.new.track_version_codes
+        # AndroidpublisherV3 returns version codes as array of strings
+        # even though version codes need to be integers
+        # https://github.com/fastlane/fastlane/issues/15622
+        version_codes = Supply::Reader.new.track_version_codes || []
+        return version_codes.compact.map(&:to_i)
       end
 
       #####################################################

data/fastlane/lib/fastlane/actions/sonar.rb

@@ -20,10 +20,12 @@ module Fastlane
         sonar_scanner_args << "-Dsonar.sourceEncoding=\"#{params[:source_encoding]}\"" if params[:source_encoding]
         sonar_scanner_args << "-Dsonar.login=\"#{params[:sonar_login]}\"" if params[:sonar_login]
         sonar_scanner_args << "-Dsonar.host.url=\"#{params[:sonar_url]}\"" if params[:sonar_url]
+        sonar_scanner_args << "-Dsonar.organization=\"#{params[:sonar_organization]}\"" if params[:sonar_organization]
         sonar_scanner_args << "-Dsonar.branch.name=\"#{params[:branch_name]}\"" if params[:branch_name]
         sonar_scanner_args << "-Dsonar.pullrequest.branch=\"#{params[:pull_request_branch]}\"" if params[:pull_request_branch]
         sonar_scanner_args << "-Dsonar.pullrequest.base=\"#{params[:pull_request_base]}\"" if params[:pull_request_base]
         sonar_scanner_args << "-Dsonar.pullrequest.key=\"#{params[:pull_request_key]}\"" if params[:pull_request_key]
+
         sonar_scanner_args << params[:sonar_runner_args] if params[:sonar_runner_args]
 
         command = [
@@ -102,6 +104,11 @@ module Fastlane
                                        description: "Pass the url of the Sonar server",
                                        optional: true,
                                        is_string: true),
+          FastlaneCore::ConfigItem.new(key: :sonar_organization,
+                                       env_name: "FL_SONAR_ORGANIZATION",
+                                       description: "Key of the organization on SonarCloud",
+                                       optional: true,
+                                       is_string: true),
           FastlaneCore::ConfigItem.new(key: :branch_name,
                                        env_name: "FL_SONAR_RUNNER_BRANCH_NAME",
                                        description: "Pass the branch name which is getting scanned",
@@ -144,6 +151,15 @@ module Fastlane
             project_version: "1.0",
             project_name: "iOS - AwesomeApp",
             sources_path: File.expand_path("../AwesomeApp")
+          )',
+          'sonar(
+            project_key: "name.gretzki.awesomeApp",
+            project_version: "1.0",
+            project_name: "iOS - AwesomeApp",
+            sources_path: File.expand_path("../AwesomeApp"),
+            sonar_organization: "myOrg",
+            sonar_login: "123456abcdef",
+            sonar_url: "https://sonarcloud.io"
           )'
         ]
       end

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

@@ -33,7 +33,7 @@ module Fastlane
             req.url("/api/upload/")
             req.body = options
           end
-        rescue Faraday::Error::TimeoutError
+        rescue Faraday::TimeoutError
           UI.crash!("Uploading build to TestFairy timed out ⏳")
         end
       end

data/fastlane/lib/fastlane/actions/update_fastlane.rb

@@ -10,18 +10,10 @@ module Fastlane
       def self.run(options)
         return if options[:no_update] # this is used to update itself
 
-        tools_to_update = options[:tools].split(',') unless options[:tools].nil?
-        tools_to_update ||= all_installed_tools
-
-        if tools_to_update.count == 0
-          UI.error("No tools specified or couldn't find any installed fastlane.tools")
-          return
-        end
-
+        tools_to_update = ALL_TOOLS
         UI.message("Looking for updates for #{tools_to_update.join(', ')}...")
 
         updater = Gem::CommandManager.instance[:update]
-        updater.options[:prerelease] = true if options[:nightly]
         cleaner = Gem::CommandManager.instance[:cleanup]
 
         gem_dir = ENV['GEM_HOME'] || Gem.dir
@@ -49,7 +41,6 @@ module Fastlane
 
         if update_needed.count == 0
           UI.success("Nothing to update ✅")
-          show_information_about_nightly_builds unless options[:nightly]
           return
         end
 
@@ -58,18 +49,13 @@ module Fastlane
 
         update_needed.each do |tool_info|
           tool = tool_info[0]
-          gem_version = tool_info[1]
           local_version = Gem::Version.new(highest_versions[tool].version)
           latest_official_version = FastlaneCore::UpdateChecker.fetch_latest(tool)
 
-          if options[:nightly]
-            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to nightly build #{gem_version.to_s.yellow}... (last official release #{latest_official_version.to_s.yellow}) 🚀")
-          else
-            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
-          end
+          UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
 
           # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
-          requirement_version = options[:nightly] ? gem_version : local_version.approximate_recommendation
+          requirement_version = local_version.approximate_recommendation
           updater.update_gem(tool, Gem::Requirement.new(requirement_version))
 
           UI.success("Finished updating #{tool}")
@@ -79,34 +65,12 @@ module Fastlane
         cleaner.options[:args] = tools_to_update
         cleaner.execute
 
-        if options[:nightly]
-          UI.success("Thanks for using fastlane's nightly builds! This makes it easier for everyone to detect regressions earlier.")
-          UI.success("Please submit an issue on GitHub if anything behaves differently than it should 🍪")
-        else
-          show_information_about_nightly_builds
-        end
-
         UI.message("fastlane.tools successfully updated! I will now restart myself... 😴")
 
         # Set no_update to true so we don't try to update again
         exec("FL_NO_UPDATE=true #{$PROGRAM_NAME} #{ARGV.join(' ')}")
       end
 
-      def self.show_information_about_nightly_builds
-        UI.message("")
-        UI.message("Please help us test early releases of fastlane by opting into nightly builds 🌃")
-        UI.message("Just replace your `update_fastlane` call with")
-        UI.message("")
-        UI.command_output("update_fastlane(nightly: true)")
-        UI.message("")
-        UI.message("Nightly builds are reviewed and tested just like the public releases 🚂")
-        UI.message("")
-      end
-
-      def self.all_installed_tools
-        Gem::Specification.select { |s| ALL_TOOLS.include?(s.name) }.map(&:name).uniq
-      end
-
       def self.description
         "Makes sure fastlane-tools are up-to-date when running fastlane"
       end
@@ -134,21 +98,17 @@ module Fastlane
 
       def self.available_options
         [
-          FastlaneCore::ConfigItem.new(key: :nightly,
-                                       env_name: "FL_UPDATE_FASTLANE_NIGHTLY",
-                                       description: "Opt-in to install and use nightly fastlane builds",
-                                       is_string: false,
-                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :no_update,
                                        env_name: "FL_NO_UPDATE",
                                        description: "Don't update during this run. This is used internally",
                                        is_string: false,
                                        default_value: false),
-          FastlaneCore::ConfigItem.new(key: :tools,
-                                       env_name: "FL_TOOLS_TO_UPDATE",
-                                       description: "Comma separated list of fastlane tools to update (e.g. `fastlane,deliver,sigh`)",
-                                       deprecated: true,
-                                       optional: true)
+          FastlaneCore::ConfigItem.new(key: :nightly,
+                                       env_name: "FL_UPDATE_FASTLANE_NIGHTLY",
+                                       description: "Opt-in to install and use nightly fastlane builds",
+                                       is_string: false,
+                                       default_value: false,
+                                       deprecated: "Nightly builds are no longer being made available")
         ]
       end
 

data/fastlane/lib/fastlane/actions/update_keychain_access_groups.rb

@@ -0,0 +1,94 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      KEYCHAIN_ACCESS_GROUPS = :KEYCHAIN_ACCESS_GROUPS
+    end
+
+    class UpdateKeychainAccessGroupsAction < Action
+      require 'plist'
+
+      def self.run(params)
+        UI.message("Entitlements File: #{params[:entitlements_file]}")
+        UI.message("New keychain access groups: #{params[:identifiers]}")
+
+        entitlements_file = params[:entitlements_file]
+        UI.user_error!("Could not find entitlements file at path '#{entitlements_file}'") unless File.exist?(entitlements_file)
+
+        # parse entitlements
+        result = Plist.parse_xml(entitlements_file)
+        UI.user_error!("Entitlements file at '#{entitlements_file}' cannot be parsed.") unless result
+
+        # keychain access groups key
+        keychain_access_groups_key = 'keychain-access-groups'
+
+        # get keychain access groups
+        keychain_access_groups_field = result[keychain_access_groups_key]
+        UI.user_error!("No existing keychain access groups field specified. Please specify an keychain access groups in the entitlements file.") unless keychain_access_groups_field
+
+        # set new keychain access groups
+        UI.message("Old keychain access groups: #{keychain_access_groups_field}")
+        result[keychain_access_groups_key] = params[:identifiers]
+
+        # save entitlements file
+        result.save_plist(entitlements_file)
+        UI.message("New keychain access groups: #{result[keychain_access_groups_key]}")
+
+        Actions.lane_context[SharedValues::KEYCHAIN_ACCESS_GROUPS] = result[keychain_access_groups_key]
+      end
+
+      def self.description
+        "This action changes the keychain access groups in the entitlements file"
+      end
+
+      def self.details
+        "Updates the Keychain Group Access Groups in the given Entitlements file, so you can have keychain access groups for the app store build and keychain access groups for an enterprise build."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :entitlements_file,
+                                       env_name: "FL_UPDATE_KEYCHAIN_ACCESS_GROUPS_ENTITLEMENTS_FILE_PATH", # The name of the environment variable
+                                       description: "The path to the entitlement file which contains the keychain access groups", # a short description of this parameter
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a path to an entitlements file. ") unless value.include?(".entitlements")
+                                         UI.user_error!("Could not find entitlements file") if !File.exist?(value) && !Helper.test?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :identifiers,
+                                       env_name: "FL_UPDATE_KEYCHAIN_ACCESS_GROUPS_IDENTIFIERS",
+                                       description: "An Array of unique identifiers for the keychain access groups. Eg. ['your.keychain.access.groups.identifiers']",
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The parameter identifiers need to be an Array.") unless value.kind_of?(Array)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['KEYCHAIN_ACCESS_GROUPS', 'The new Keychain Access Groups']
+        ]
+      end
+
+      def self.authors
+        ["yutae"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'update_keychain_access_groups(
+            entitlements_file: "/path/to/entitlements_file.entitlements",
+            identifiers: ["your.keychain.access.groups.identifiers"]
+          )'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/environment_printer.rb

@@ -50,11 +50,11 @@ module Fastlane
     end
 
     def self.print_loaded_plugins
-      ENV["FASTLANE_ENV_PRINTER"] = "enabled"
       env_output =  "### Loaded fastlane plugins:\n"
       env_output << "\n"
       plugin_manager = Fastlane::PluginManager.new
-      plugin_manager.load_plugins
+      plugin_manager.load_plugins(print_table: false)
+
       if plugin_manager.available_plugins.length <= 0
         env_output << "**No plugins Loaded**\n"
       else
@@ -211,7 +211,7 @@ module Fastlane
         "OS" => os_version,
         "Ruby" => RUBY_VERSION,
         "Bundler?" => Helper.bundler?,
-        "Git" => `git --version`.strip.split("\n").first,
+        "Git" => git_version,
         "Installation Source" => anonymized_path($PROGRAM_NAME),
         "Host" => "#{product} #{version} (#{build})",
         "Ruby Lib Dir" => anonymized_path(RbConfig::CONFIG['libdir']),
@@ -293,5 +293,11 @@ module Fastlane
       require 'open3'
       Open3.popen3('pbcopy') { |input, _, _| input << string }
     end
+
+    def self.git_version
+      return `git --version`.strip.split("\n").first
+    rescue
+      return "not found"
+    end
   end
 end

data/fastlane/lib/fastlane/fast_file.rb

@@ -195,6 +195,7 @@ module Fastlane
     #  sh("ls")
     #  sh("ls", log: false)
     #  sh(command: "ls")
+    #  sh(command: "ls", step_name: "listing the files")
     #  sh(command: "ls", log: false)
     def sh(*args, &b)
       # First accepts hash (or named keywords) like other actions
@@ -212,8 +213,8 @@ module Fastlane
       end
     end
 
-    def self.sh(*command, log: true, error_callback: nil, &b)
-      command_header = log ? Actions.shell_command_from_args(*command) : "shell command"
+    def self.sh(*command, step_name: nil, log: true, error_callback: nil, &b)
+      command_header = log ? step_name || Actions.shell_command_from_args(*command) : "shell command"
       Actions.execute_action(command_header) do
         Actions.sh_no_action(*command, log: log, error_callback: error_callback, &b)
       end

data/fastlane/lib/fastlane/lane_manager.rb

@@ -113,7 +113,7 @@ module Fastlane
         rows: FastlaneCore::PrintTable.transform_output(rows)
       )
 
-      UI.message("Welcome to fastlane! Here's what your app is setup to do:")
+      UI.message("Welcome to fastlane! Here's what your app is set up to do:")
 
       puts(table)
 

data/fastlane/lib/fastlane/plugins/plugin_manager.rb

@@ -278,7 +278,7 @@ module Fastlane
     #   fastlane-plugin-[plugin_name]
     # This will make sure to load the action
     # and all its helpers
-    def load_plugins
+    def load_plugins(print_table: true)
       UI.verbose("Checking if there are any plugins that should be loaded...")
 
       loaded_plugins = false
@@ -311,7 +311,7 @@ module Fastlane
         UI.error("Please follow the troubleshooting guide: #{TROUBLESHOOTING_URL}")
       end
 
-      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || FastlaneCore::Env.truthy?("FASTLANE_ENV_PRINTER")
+      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || !print_table
 
       # We want to avoid printing output other than the version number if we are running `fastlane -v`
       print_plugin_information(self.plugin_references) unless skip_print_plugin_info
@@ -319,9 +319,12 @@ module Fastlane
 
     # Prints a table all the plugins that were loaded
     def print_plugin_information(references)
+      no_action_found = false
+
       rows = references.collect do |current|
         if current[1][:actions].empty?
           # Something is wrong with this plugin, no available actions
+          no_action_found = true
           [current[0].red, current[1][:version_number], "No actions found".red]
         else
           [current[0], current[1][:version_number], current[1][:actions].join("\n")]
@@ -335,6 +338,13 @@ module Fastlane
         headings: ["Plugin", "Version", "Action"]
       }))
       puts("")
+
+      if no_action_found
+        puts("[!] No actions were found while loading one or more plugins".red)
+        puts("    Please use `bundle exec fastlane` with plugins".red)
+        puts("    More info - https://docs.fastlane.tools/plugins/using-plugins/#run-with-plugins".red)
+        puts("")
+      end
     end
 
     #####################################################