fastlane 2.139.0 → 2.144.0

data/fastlane/lib/fastlane/actions/set_github_release.rb

@@ -241,7 +241,7 @@ module Fastlane
       end
 
       def self.return_type
-        :hash_of_strings
+        :hash
       end
 
       def self.authors

data/fastlane/lib/fastlane/actions/spm.rb

@@ -15,6 +15,9 @@ module Fastlane
         end
         if params[:xcpretty_output]
           cmd += ["2>&1", "|", "xcpretty", "--#{params[:xcpretty_output]}"]
+          if params[:xcpretty_args]
+            cmd << (params[:xcpretty_args]).to_s
+          end
           cmd = %w(set -o pipefail &&) + cmd
         end
 
@@ -67,6 +70,11 @@ module Fastlane
                                        verify_block: proc do |value|
                                          UI.user_error!("Please pass a valid xcpretty output type: (#{xcpretty_output_types.join('|')})") unless xcpretty_output_types.include?(value)
                                        end),
+          FastlaneCore::ConfigItem.new(key: :xcpretty_args,
+                                       env_name: "FL_SPM_XCPRETTY_ARGS",
+                                       description: "Pass in xcpretty additional command line arguments (e.g. '--test --no-color' or '--tap --no-utf'), requires xcpretty_output to be specified also",
+                                       type: String,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :verbose,
                                        short_option: "-v",
                                        env_name: "FL_SPM_VERBOSE",

data/fastlane/lib/fastlane/actions/swiftlint.rb

@@ -13,13 +13,7 @@ module Fastlane
 
         command = (params[:executable] || "swiftlint").dup
         command << " #{params[:mode]}"
-        command << " --path #{params[:path].shellescape}" if params[:path]
-        command << supported_option_switch(params, :strict, "0.9.2", true)
-        command << " --config #{params[:config_file].shellescape}" if params[:config_file]
-        command << " --reporter #{params[:reporter]}" if params[:reporter]
-        command << supported_option_switch(params, :quiet, "0.9.0", true)
-        command << supported_option_switch(params, :format, "0.11.0", true) if params[:mode] == :autocorrect
-        command << " --compiler-log-path #{params[:compiler_log_path].shellescape}" if params[:compiler_log_path]
+        command << optional_flags(params)
 
         if params[:files]
           if version < Gem::Version.new('0.5.1')
@@ -37,15 +31,37 @@ module Fastlane
           Actions.sh(command)
         rescue
           handle_swiftlint_error(params[:ignore_exit_status], $?.exitstatus)
+          raise if params[:raise_if_swiftlint_error]
         end
       end
 
+      def self.optional_flags(params)
+        command = ""
+        command << " --path #{params[:path].shellescape}" if params[:path]
+        command << supported_option_switch(params, :strict, "0.9.2", true)
+        command << " --config #{params[:config_file].shellescape}" if params[:config_file]
+        command << " --reporter #{params[:reporter]}" if params[:reporter]
+        command << supported_option_switch(params, :quiet, "0.9.0", true)
+        command << supported_option_switch(params, :format, "0.11.0", true) if params[:mode] == :autocorrect
+        command << supported_no_cache_option(params) if params[:no_cache]
+        command << " --compiler-log-path #{params[:compiler_log_path].shellescape}" if params[:compiler_log_path]
+        return command
+      end
+
       # Get current SwiftLint version
       def self.swiftlint_version(executable: nil)
         binary = executable || 'swiftlint'
         Gem::Version.new(`#{binary} version`.chomp)
       end
 
+      def self.supported_no_cache_option(params)
+        if params[:mode] == :autocorrect || params[:mode] == :lint
+          return " --no-cache"
+        else
+          return ""
+        end
+      end
+
       # Return "--option" switch if option is on and current SwiftLint version is greater or equal than min version.
       # Return "" otherwise.
       def self.supported_option_switch(params, option, min_version, can_ignore = false)
@@ -106,10 +122,22 @@ module Fastlane
                                        is_string: false,
                                        type: Boolean,
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :raise_if_swiftlint_error,
+                                       description: "Raises an error if swiftlint fails, so you can fail CI/CD jobs if necessary \
+                                                    (true/false)",
+                                       default_value: false,
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :reporter,
-                                       description: 'Choose output reporter',
+                                       description: "Choose output reporter. Available: xcode, json, csv, checkstyle, junit, html, \
+                                                     emoji, sonarqube, markdown, github-actions-logging",
                                        is_string: true,
-                                       optional: true),
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         available = ['xcode', 'json', 'csv', 'checkstyle', 'junit', 'html', 'emoji', 'sonarqube', 'markdown', 'github-actions-logging']
+                                         UI.user_error!("Available values are '#{available.join("', '")}'") unless available.include?(value)
+                                       end),
           FastlaneCore::ConfigItem.new(key: :quiet,
                                        description: "Don't print status logs like 'Linting <file>' & 'Done linting'",
                                        default_value: false,
@@ -126,6 +154,12 @@ module Fastlane
                                        is_string: false,
                                        type: Boolean,
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_cache,
+                                       description: "Ignore the cache when mode is :autocorrect or :lint",
+                                       default_value: false,
+                                       is_string: false,
+                                       type: Boolean,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :compiler_log_path,
                                        description: "Compiler log path when mode is :analyze",
                                        is_string: true,
@@ -161,7 +195,9 @@ module Fastlane
               "AppDelegate.swift",
               "path/to/project/Model.swift"
             ],
+            raise_if_swiftlint_error: true,      # Allow fastlane to raise an error if swiftlint fails
             ignore_exit_status: true              # Allow fastlane to continue even if SwiftLint returns a non-zero exit status
+
           )'
         ]
       end

data/fastlane/lib/fastlane/actions/update_code_signing_settings.rb

@@ -0,0 +1,190 @@
+require 'xcodeproj'
+module Fastlane
+  module Actions
+    class UpdateCodeSigningSettingsAction < Action
+      def self.run(params)
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for code signing settings")
+        path = params[:path]
+        path = File.join(File.expand_path(path), "project.pbxproj")
+
+        project = Xcodeproj::Project.open(params[:path])
+        UI.user_error!("Could not find path to project config '#{path}'. Pass the path to your project (not workspace)!") unless File.exist?(path)
+        UI.message("Updating the Automatic Codesigning flag to #{params[:use_automatic_signing] ? 'enabled' : 'disabled'} for the given project '#{path}'")
+
+        unless project.root_object.attributes["TargetAttributes"]
+          UI.user_error!("Seems to be a very old project file format - please open your project file in a more recent version of Xcode")
+          return false
+        end
+
+        target_dictionary = project.targets.map { |f| { name: f.name, uuid: f.uuid, build_configuration_list: f.build_configuration_list } }
+        target_attributes = project.root_object.attributes["TargetAttributes"]
+        changed_targets = []
+
+        # make sure TargetAttributes exist for all targets
+        target_dictionary.each do |props|
+          unless target_attributes.key?(props[:uuid])
+            target_attributes[props[:uuid]] = {}
+          end
+        end
+
+        target_attributes.each do |target, sett|
+          found_target = target_dictionary.detect { |h| h[:uuid] == target }
+          if params[:targets]
+            # get target name
+            unless params[:targets].include?(found_target[:name])
+              UI.important("Skipping #{found_target[:name]} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+          build_configuration_list = found_target[:build_configuration_list]
+          build_configuration_list.set_setting("CODE_SIGN_STYLE", style_value)
+          sett["ProvisioningStyle"] = style_value
+
+          if params[:team_id]
+            sett["DevelopmentTeam"] = params[:team_id]
+            build_configuration_list.set_setting("DEVELOPMENT_TEAM", params[:team_id])
+            UI.important("Set Team id to: #{params[:team_id]} for target: #{found_target[:name]}")
+          end
+          if params[:code_sign_identity]
+            build_configuration_list.set_setting("CODE_SIGN_IDENTITY", params[:code_sign_identity])
+
+            # We also need to update the value if it was overridden for a specific SDK
+            build_configuration_list.build_configurations.each do |build_configuration|
+              codesign_build_settings_keys = build_configuration.build_settings.keys.select { |key| key.to_s.match(/CODE_SIGN_IDENTITY.*/) }
+              codesign_build_settings_keys.each do |setting|
+                build_configuration_list.set_setting(setting, params[:code_sign_identity])
+              end
+            end
+            UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{found_target[:name]}")
+          end
+          if params[:profile_name]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+            UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{found_target[:name]}")
+          end
+          # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+          if params[:profile_uuid]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE", params[:profile_uuid])
+            UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{found_target[:name]}")
+          end
+          if params[:bundle_identifier]
+            build_configuration_list.set_setting("PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+            UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{found_target[:name]}")
+          end
+
+          changed_targets << found_target[:name]
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          target_dictionary.each do |target|
+            UI.important("\t* #{target[:name]}")
+          end
+        else
+          UI.success("Successfully updated project settings to use Code Sign Style = '#{params[:use_automatic_signing] ? 'Automatic' : 'Manual'}'")
+          UI.success("Modified Targets:")
+          changed_targets.each do |target|
+            UI.success("\t * #{target}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.description
+        "Configures Xcode's Codesigning options"
+      end
+
+      def self.details
+        "Configures Xcode's Codesigning options of all targets in the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_PROJECT_SIGNING_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path is invalid") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :use_automatic_signing,
+                                       env_name: "FL_PROJECT_USE_AUTOMATIC_SIGNING",
+                                       description: "Defines if project should use automatic signing",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project",
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :targets,
+                                       env_name: "FL_PROJECT_SIGNING_TARGETS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify targets you want to toggle the signing mech. (default to all targets)",
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          ' # manual code signing
+          update_code_signing_settings(
+            use_automatic_signing: false,
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          ' # automatic code signing
+          update_code_signing_settings(
+            use_automatic_signing: true,
+            path: "demo-project/demo/demo.xcodeproj"
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+
+      def self.return_value
+        "The current status (boolean) of codesigning after modification"
+      end
+
+      def self.authors
+        ["mathiasAichinger", "hjanuschka", "p4checo", "portellaa", "aeons", "att55"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/update_plist.rb

@@ -39,7 +39,7 @@ module Fastlane
       end
 
       def self.details
-        "This action allows you to modify any `plist` file."
+        "This action allows you to modify any value inside any `plist` file."
       end
 
       def self.available_options
@@ -57,11 +57,46 @@ module Fastlane
       end
 
       def self.author
-        'rishabhtayal'
+        ["rishabhtayal", "matthiaszarzecki"]
       end
 
       def self.example_code
         [
+          'update_plist( # Updates the CLIENT_ID and GOOGLE_APP_ID string entries in the plist-file
+            plist_path: "path/to/your_plist_file.plist",
+            block: proc do |plist|
+              plist[:CLIENT_ID] = "new_client_id"
+              plist[:GOOGLE_APP_ID] = "new_google_app_id"
+            end
+          )',
+          'update_plist( # Sets a boolean entry
+            plist_path: "path/to/your_plist_file.plist",
+            block: proc do |plist|
+              plist[:boolean_entry] = true
+            end
+          )',
+          'update_plist( # Sets a number entry
+            plist_path: "path/to/your_plist_file.plist",
+            block: proc do |plist|
+              plist[:number_entry] = 13
+            end
+          )',
+          'update_plist( # Sets an array-entry with multiple sub-types
+            plist_path: "path/to/your_plist_file.plist",
+            block: proc do |plist|
+              plist[:array_entry] = ["entry_01", true, 1243]
+            end
+          )',
+          'update_plist( # The block can contain logic too
+            plist_path: "path/to/your_plist_file.plist",
+            block: proc do |plist|
+              if options[:environment] == "production"
+                plist[:CLIENT_ID] = "new_client_id_production"
+              else
+                plist[:CLIENT_ID] = "new_client_id_development"
+              end
+            end
+          )',
           'update_plist( # Advanced processing: find URL scheme for particular key and replace value
             plist_path: "path/to/Info.plist",
             block: proc do |plist|

data/fastlane/lib/fastlane/actions/upload_symbols_to_crashlytics.rb

@@ -10,8 +10,8 @@ module Fastlane
         find_gsp_path(params)
         find_api_token(params)
 
-        if !params[:api_token] && !params[:gsp_path]
-          UI.user_error!('Either Fabric API key or path to Firebase Crashlytics GoogleService-Info.plist must be given.')
+        if !params[:app_id] && !params[:gsp_path] && !params[:api_token]
+          UI.user_error!('Either Firebase Crashlytics App ID, path to GoogleService-Info.plist or legacy Fabric API key must be given.')
         end
 
         dsym_paths = []
@@ -87,7 +87,9 @@ module Fastlane
         UI.message("Uploading '#{path}'...")
         command = []
         command << File.expand_path(params[:binary_path]).shellescape
-        if params[:gsp_path]
+        if params[:app_id]
+          command << "-ai #{params[:app_id].shellescape}"
+        elsif params[:gsp_path]
           command << "-gsp #{params[:gsp_path].shellescape}"
         elsif params[:api_token]
           command << "-a #{params[:api_token]}"
@@ -186,6 +188,14 @@ module Fastlane
                                          UI.user_error!("Couldn't find file at path '#{File.expand_path(value)}'") unless File.exist?(value)
                                          UI.user_error!("No Path to GoogleService-Info.plist for Firebase Crashlytics given, pass using `gsp_path: 'path'`") if value.to_s.length == 0
                                        end),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       env_name: "CRASHLYTICS_APP_ID",
+                                       sensitive: true,
+                                       optional: true,
+                                       description: "Firebase Crashlytics APP ID",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No App ID for Firebase Crashlytics given, pass using `app_id: 'appId'`") if value.to_s.length == 0
+                                       end),
           FastlaneCore::ConfigItem.new(key: :binary_path,
                                        env_name: "FL_UPLOAD_SYMBOLS_TO_CRASHLYTICS_BINARY_PATH",
                                        description: "The path to the upload-symbols file of the Fabric app",

data/fastlane/lib/fastlane/actions/upload_to_app_store.rb

@@ -11,6 +11,7 @@ module Fastlane
           config.load_configuration_file("Deliverfile")
           config[:screenshots_path] = Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH] if Actions.lane_context[SharedValues::SNAPSHOT_SCREENSHOTS_PATH]
           config[:ipa] = Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] if Actions.lane_context[SharedValues::IPA_OUTPUT_PATH]
+          config[:pkg] = Actions.lane_context[SharedValues::PKG_OUTPUT_PATH] if Actions.lane_context[SharedValues::PKG_OUTPUT_PATH]
 
           return config if Helper.test?
           Deliver::Runner.new(config).run

data/fastlane/lib/fastlane/fast_file.rb

@@ -263,7 +263,7 @@ module Fastlane
     # @param branch [String] The branch to checkout in the repository
     # @param path [String] The path to the Fastfile
     # @param version [String, Array] Version requirement for repo tags
-    def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile', version: nil)
+    def import_from_git(url: nil, branch: 'HEAD', path: 'fastlane/Fastfile', version: nil, dependencies: [])
       UI.user_error!("Please pass a path to the `import_from_git` action") if url.to_s.length == 0
 
       Actions.execute_action('import_from_git') do
@@ -280,6 +280,10 @@ module Fastlane
 
           branch_option = "--branch #{branch}" if branch != 'HEAD'
 
+          checkout_dependencies = dependencies.map(&:shellescape).join(" ")
+
+          checkout_path = "#{path.shellescape} #{checkout_dependencies}"
+
           UI.message("Cloning remote git repo...")
           Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
             Actions.sh("git clone #{url.shellescape} #{clone_folder.shellescape} --depth 1 -n #{branch_option}")
@@ -292,7 +296,7 @@ module Fastlane
             UI.user_error!("No tag found matching #{version.inspect}") if checkout_param.nil?
           end
 
-          Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{path.shellescape}")
+          Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{checkout_path}")
 
           # We also want to check out all the local actions of this fastlane setup
           containing = path.split(File::SEPARATOR)[0..-2]
@@ -304,7 +308,13 @@ module Fastlane
             # We don't care about a failure here, as local actions are optional
           end
 
-          return_value = import(File.join(clone_folder, path))
+          return_value = nil
+          if dependencies.any?
+            return_value = [import(File.join(clone_folder, path))]
+            return_value += dependencies.map { |file_path| import(File.join(clone_folder, file_path)) }
+          else
+            return_value = import(File.join(clone_folder, path))
+          end
 
           action_completed('import_from_git', status: FastlaneCore::ActionCompletionStatus::SUCCESS)