fastlane 2.129.0 → 2.134.0

data/fastlane/lib/fastlane/actions/pod_push.rb

@@ -47,6 +47,10 @@ module Fastlane
           command << "--verbose"
         end
 
+        if params[:use_modular_headers]
+          command << "--use-modular-headers"
+        end
+
         result = Actions.sh(command.join(' '))
         UI.success("Successfully pushed Podspec ⬆️ ")
         return result
@@ -118,7 +122,12 @@ module Fastlane
                                        optional: true,
                                        type: Boolean,
                                        default_value: false,
-                                       env_name: "FL_POD_PUSH_VERBOSE")
+                                       env_name: "FL_POD_PUSH_VERBOSE"),
+          FastlaneCore::ConfigItem.new(key: :use_modular_headers,
+                                       description: "Use modular headers option during validation",
+                                       optional: true,
+                                       type: Boolean,
+                                       env_name: "FL_POD_PUSH_USE_MODULAR_HEADERS")
         ]
       end
 

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

@@ -7,41 +7,53 @@ module Fastlane
         [:ios, :mac].include?(platform)
       end
 
+      def self.file_column_headers
+        ['Device ID', 'Device Name', 'Device Platform']
+      end
+
       def self.run(params)
-        require 'spaceship'
+        if params[:devices]
+          new_devices = params[:devices].map do |name, udid|
+            [udid, name]
+          end
+        elsif params[:devices_file]
+          require 'csv'
 
-        devices = params[:devices]
-        devices_file = params[:devices_file]
+          devices_file = CSV.read(File.expand_path(File.join(params[:devices_file])), col_sep: "\t")
+          unless devices_file.first == file_column_headers.first(2) || devices_file.first == file_column_headers
+            UI.user_error!("Please provide a file according to the Apple Sample UDID file (https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip)")
+          end
 
-        mac = params[:platform] == "mac"
+          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)
+            row
+          end
+        else
+          UI.user_error!("You must pass either a valid `devices` or `devices_file`. Please check the readme.")
+        end
 
+        require 'spaceship'
         credentials = CredentialsManager::AccountManager.new(user: params[:username])
         Spaceship.login(credentials.user, credentials.password)
         Spaceship.select_team
 
         UI.message("Fetching list of currently registered devices...")
-        existing_devices = Spaceship::Device.all(mac: mac)
-
-        if devices
-          device_objs = devices.map do |k, v|
-            next if existing_devices.map(&:udid).include?(v)
-            try_create_device(name: k, udid: v, mac: mac)
-          end
-        elsif devices_file
-          require 'csv'
+        all_platforms = Set[params[:platform]]
+        new_devices.each do |device|
+          next if device[2].nil?
+          all_platforms.add(device[2])
+        end
+        supported_platforms = all_platforms.select { |platform| self.is_supported?(platform.to_sym) }
 
-          devices_file = CSV.read(File.expand_path(File.join(devices_file)), col_sep: "\t")
-          UI.user_error!("Please provide a file according to the Apple Sample UDID file (https://devimages.apple.com.edgekey.net/downloads/devices/Multiple-Upload-Samples.zip)") unless devices_file.first == ['Device ID', 'Device Name']
+        existing_devices = supported_platforms.flat_map { |platform| Spaceship::Device.all(mac: platform == "mac") }
 
-          device_objs = devices_file.drop(1).map do |device|
-            next if existing_devices.map(&:udid).include?(device[0])
+        device_objs = new_devices.map do |device|
+          next if existing_devices.map(&:udid).include?(device[0])
 
-            UI.user_error!("Invalid device line, please provide a file according to the Apple Sample UDID file (http://devimages.apple.com/downloads/devices/Multiple-Upload-Samples.zip)") unless device.count == 2
+          device_platform_supported = !device[2].nil? && self.is_supported?(device[2].to_sym)
+          mac = (device_platform_supported ? device[2] : params[:platform]) == "mac"
 
-            try_create_device(name: device[1], udid: device[0], mac: mac)
-          end
-        else
-          UI.user_error!("You must pass either a valid `devices` or `devices_file`. Please check the readme.")
+          try_create_device(name: device[1], udid: device[0], mac: mac)
         end
 
         UI.success("Successfully registered new devices.")
@@ -55,6 +67,10 @@ module Fastlane
         UI.crash!("Failed to register new device (name: #{name}, UDID: #{udid})")
       end
 
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
       def self.description
         "Registers new devices to the Apple Dev Portal"
       end

data/fastlane/lib/fastlane/actions/resign.rb

@@ -26,7 +26,7 @@ module Fastlane
           )',
           '# You may provide multiple provisioning profiles if the application contains nested
           # applications or app extensions, which need their own provisioning profile.
-          # You can do so by passing an array of provisiong profile strings or a hash
+          # You can do so by passing an array of provisioning profile strings or a hash
           # that associates provisioning profile values to bundle identifier keys.
           resign(
             ipa: "path/to/ipa", # can omit if using the `ipa` action
@@ -75,7 +75,7 @@ module Fastlane
                                                  else [value]
                                                  end
                                          files.each do |file|
-                                           UI.user_error!("Couldn't find provisiong profile at path '#{file}'") unless File.exist?(file)
+                                           UI.user_error!("Couldn't find provisioning profile at path '#{file}'") unless File.exist?(file)
                                          end
                                        end),
           FastlaneCore::ConfigItem.new(key: :version,

data/fastlane/lib/fastlane/actions/slather.rb

@@ -263,6 +263,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :binary_file,
                                        env_name: "FL_SLATHER_BINARY_FILE",
                                        description: "Binary file name to be used for code coverage",
+                                       type: Array,
                                        skip_type_validation: true, # skipping validation for backwards compatibility with Boolean type
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :arch,

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/commands_generator.rb

@@ -329,6 +329,22 @@ module Fastlane
         end
       end
 
+      #####################################################
+      # @!group Swift
+      #####################################################
+
+      if FastlaneCore::FastlaneFolder.swift?
+        command :generate_swift do |c|
+          c.syntax = 'fastlane generate_swift'
+          c.description = 'Generates additional Swift APIs for plugins and local actions'
+
+          c.action do |args, options|
+            SwiftActionsAPIGenerator.new(target_output_path: FastlaneCore::FastlaneFolder.swift_folder_path).generate_swift
+            SwiftPluginsAPIGenerator.new(target_output_path: FastlaneCore::FastlaneFolder.swift_folder_path).generate_swift
+          end
+        end
+      end
+
       default_command(:trigger)
       run!
     end

data/fastlane/lib/fastlane/environment_printer.rb

@@ -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

@@ -26,10 +26,15 @@ module Fastlane
                 'you should turn off smart quotes in your editor of choice.')
       end
 
-      content.scan(/^\s*require (.*)/).each do |current|
+      content.scan(/^\s*require ["'](.*?)["']/).each do |current|
         gem_name = current.last
         next if gem_name.include?(".") # these are local gems
-        UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require #{gem_name}` to ensure the gem is installed locally.")
+
+        begin
+          require(gem_name)
+        rescue LoadError
+          UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require '#{gem_name}'` to ensure the gem is installed locally.")
+        end
       end
 
       parse(content, @path)
@@ -190,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
@@ -207,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