fastlane 2.141.0 → 2.146.0

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

@@ -93,7 +93,7 @@ module Fastlane
                                        env_name: "FL_SETUP_CI_PROVIDER",
                                        description: "CI provider. If none is set, the provider is detected automatically",
                                        is_string: true,
-                                       default_value: false,
+                                       optional: true,
                                        verify_block: proc do |value|
                                          value = value.to_s
                                          # Validate both 'travis' and 'circleci' for backwards compatibility, even

data/fastlane/lib/fastlane/actions/setup_jenkins.rb

@@ -14,7 +14,10 @@ module Fastlane
         "SCAN_DERIVED_DATA_PATH",
         "SCAN_OUTPUT_DIRECTORY",
         "SCAN_RESULT_BUNDLE",
-        "XCODE_DERIVED_DATA_PATH"
+        "XCODE_DERIVED_DATA_PATH",
+        "MATCH_KEYCHAIN_NAME",
+        "MATCH_KEYCHAIN_PASSWORD",
+        "MATCH_READONLY"
       ].freeze
 
       def self.run(params)
@@ -40,6 +43,9 @@ module Fastlane
             add_to_search_list: params[:add_keychain_to_search_list],
             set_default: params[:set_default_keychain]
           )
+          ENV['MATCH_KEYCHAIN_NAME'] ||= keychain_path
+          ENV['MATCH_KEYCHAIN_PASSWORD'] ||= params[:keychain_password]
+          ENV["MATCH_READONLY"] ||= true.to_s
         end
 
         # Code signing identity
@@ -90,6 +96,7 @@ module Fastlane
       def self.details
         list = <<-LIST.markdown_list(true)
           Adds and unlocks keychains from Jenkins 'Keychains and Provisioning Profiles Plugin'
+          Sets unlocked keychain to be used by Match
           Sets code signing identity from Jenkins 'Keychains and Provisioning Profiles Plugin'
           Sets output directory to './output' (gym, scan and backup_xcarchive)
           Sets derived data path to './derivedData' (xcodebuild, gym, scan and clear_derived_data, carthage)
@@ -99,7 +106,9 @@ module Fastlane
         [
           list,
           "This action helps with Jenkins integration. Creates own derived data for each job. All build results like IPA files and archives will be stored in the `./output` directory.",
-          "The action also works with [Keychains and Provisioning Profiles Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Keychains+and+Provisioning+Profiles+Plugin), the selected keychain will be automatically unlocked and the selected code signing identity will be used. By default this action will only work when _fastlane_ is executed on a CI system."
+          "The action also works with [Keychains and Provisioning Profiles Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Keychains+and+Provisioning+Profiles+Plugin), the selected keychain will be automatically unlocked and the selected code signing identity will be used.",
+          "[Match](https://docs.fastlane.tools/actions/match/) will be also set up to use the unlocked keychain and set in read-only mode, if its environment variables were not yet defined.",
+          "By default this action will only work when _fastlane_ is executed on a CI system."
         ].join("\n")
       end
 

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

@@ -241,7 +241,7 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :ignore,
                                        env_name: "FL_SLATHER_IGNORE",
                                        description: "Tell slather to ignore files matching a path or any path from an array of paths",
-                                       is_string: false,
+                                       type: Array,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :verbose,
                                        env_name: "FL_SLATHER_VERBOSE",

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,198 @@
+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
+
+        changed_targets = []
+        changed_build_configurations = []
+
+        project.targets.each do |target|
+          if params[:targets]
+            unless params[:targets].include?(target.name)
+              UI.important("Skipping #{target.name} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          target.build_configurations.each do |config|
+            if params[:build_configurations]
+              unless params[:build_configurations].include?(config.name)
+                UI.important("Skipping #{config.name} not selected (#{params[:build_configurations].join(',')})")
+                next
+              end
+            end
+
+            style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+            set_build_setting(config, "CODE_SIGN_STYLE", style_value)
+
+            if params[:team_id]
+              set_build_setting(config, "DEVELOPMENT_TEAM", params[:team_id])
+              UI.important("Set Team id to: #{params[:team_id]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:code_sign_identity]
+              set_build_setting(config, "CODE_SIGN_IDENTITY", params[:code_sign_identity])
+              UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:profile_name]
+              set_build_setting(config, "PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+              UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+            if params[:profile_uuid]
+              set_build_setting(config, "PROVISIONING_PROFILE", params[:profile_uuid])
+              UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+            if params[:bundle_identifier]
+              set_build_setting(config, "PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+              UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{target.name} for build configuration: #{config.name}")
+            end
+
+            changed_build_configurations << config.name
+          end
+
+          changed_targets << target.name
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          project.targets.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
+
+          UI.success("Modified Build Configurations:")
+          changed_build_configurations.each do |name|
+            UI.success("\t * #{name}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.set_build_setting(configuration, name, value)
+        codesign_build_settings_keys = configuration.build_settings.keys.select { |key| key.to_s.match(/#{name}.*/) }
+        codesign_build_settings_keys.each do |key|
+          configuration.build_settings[key] = value
+        end
+      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: :build_configurations,
+                                       env_name: "FL_PROJECT_SIGNING_BUILD_CONFIGURATIONS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify build_configurations 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/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]}"
@@ -128,7 +130,7 @@ module Fastlane
       end
 
       def self.find_binary_path(params)
-        params[:binary_path] ||= (Dir["/Applications/Fabric.app/**/upload-symbols"] + Dir["./Pods/**/upload-symbols"]).last
+        params[:binary_path] ||= (Dir["/Applications/Fabric.app/**/upload-symbols"] + Dir["./Pods/Fabric/upload-symbols"] + Dir["./Pods/FirebaseCrashlytics/upload-symbols"]).last
         UI.user_error!("Failed to find Fabric's upload_symbols binary at /Applications/Fabric.app/**/upload-symbols or ./Pods/**/upload-symbols. Please specify the location of the binary explicitly by using the binary_path option") unless params[:binary_path]
 
         params[:binary_path] = File.expand_path(params[:binary_path])
@@ -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/verify_build.rb

@@ -46,7 +46,7 @@ module Fastlane
 
         parts = cert_info.strip.split(/\r?\n/)
         parts.each do |part|
-          if part =~ /\AAuthority=i(Phone|OS)/
+          if part =~ /\AAuthority=(iPhone|iOS|Apple)\s(Distribution|Development)/
             type = part.split('=')[1].split(':')[0]
             values['provisioning_type'] = type.downcase =~ /distribution/i ? "distribution" : "development"
           end

data/fastlane/lib/fastlane/helper/adb_helper.rb

@@ -24,7 +24,7 @@ module Fastlane
           adb_path = File.join(android_home, "platform-tools", "adb")
         end
 
-        self.adb_path = adb_path
+        self.adb_path = File.expand_path(adb_path)
         self.adb_host = adb_host
       end
 

data/fastlane/lib/fastlane/helper/s3_client_helper.rb

@@ -0,0 +1,61 @@
+require 'aws-sdk-s3'
+
+module Fastlane
+  module Helper
+    class S3ClientHelper
+      attr_reader :client
+
+      def initialize(access_key: nil, secret_access_key: nil, region: nil)
+        creds = Aws::Credentials.new(access_key, secret_access_key)
+        Aws.config.update(
+          region: region,
+          credentials: creds
+        )
+      end
+
+      def list_buckets
+        return client.list_buckets
+      end
+
+      def upload_file(bucket_name, file_name, file_data, acl)
+        bucket = find_bucket!(bucket_name)
+        details = {
+          acl: acl,
+          key: file_name,
+          body: file_data
+        }
+        obj = bucket.put_object(details)
+
+        # When you enable versioning on a S3 bucket,
+        # writing to an object will create an object version
+        # instead of replacing the existing object.
+        # http://docs.aws.amazon.com/AWSRubySDK/latest/AWS/S3/ObjectVersion.html
+        if obj.kind_of?(Aws::S3::ObjectVersion)
+          obj = obj.object
+        end
+
+        # Return public url
+        obj.public_url.to_s
+      end
+
+      def delete_file(bucket_name, file_name)
+        bucket = find_bucket!(bucket_name)
+        file = bucket.object(file_name)
+        file.delete
+      end
+
+      def find_bucket!(bucket_name)
+        bucket = Aws::S3::Bucket.new(bucket_name, client: client)
+        raise "Bucket '#{bucket_name}' not found" unless bucket.exists?
+
+        return bucket
+      end
+    end
+
+    private
+
+    def client
+      @client ||= Aws::S3::Client.new
+    end
+  end
+end