fastlane 2.143.0 → 2.144.0

data/fastlane/lib/fastlane/actions/docs/sync_code_signing.md

@@ -465,13 +465,13 @@ You'll be asked for the new password on all your machines on the next run.
 
 ### Import
 
-To import and encrypt a certificate (`.cer`) and the private key (`.p12`) into the _match_ repo run:
+To import and encrypt a certificate (`.cer`), the private key (`.p12`) and the provisioning profiles (`.mobileprovision` or `.provisionprofile`) into the _match_ repo run:
 
 ```no-highlight
 fastlane match import
 ```
 
-You'll be prompted for the certificate (`.cer`) and the private key (`.p12`) paths. _match_ will first validate the certificate (`.cer`) against the Developer Portal before importing the certificate (`.cer`) and the private key (`.p12`).
+You'll be prompted for the certificate (`.cer`), the private key (`.p12`) and the provisioning profiles (`.mobileprovision` or `.provisionprofile`) paths. _match_ will first validate the certificate (`.cer`) against the Developer Portal before importing the certificate, the private key and the provisioning profiles into the specified _match_ repository.
 
 ### Manual Decrypt
 

data/fastlane/lib/fastlane/actions/pod_lib_lint.rb

@@ -26,6 +26,7 @@ module Fastlane
         command << "--platforms=#{params[:platforms]}" if params[:platforms]
         command << "--skip-import-validation" if params[:skip_import_validation]
         command << "--skip-tests" if params[:skip_tests]
+        command << "--analyze" if params[:analyze]
 
         result = Actions.sh(command.join(' '))
         UI.success("Pod lib lint Successfully ⬆️ ")
@@ -144,7 +145,12 @@ module Fastlane
                                        description: "Lint skips building and running tests during validation (available since cocoapods >= 1.3)",
                                        type: Boolean,
                                        default_value: false,
-                                       env_name: "FL_POD_LIB_LINT_SKIP_TESTS")
+                                       env_name: "FL_POD_LIB_LINT_SKIP_TESTS"),
+          FastlaneCore::ConfigItem.new(key: :analyze,
+                                       description: "Validate with the Xcode Static Analysis tool (available since cocoapods >= 1.6.1)",
+                                       type: Boolean,
+                                       default_value: false,
+                                       env_name: "FL_POD_LIB_LINT_ANALYZE")
         ]
       end
 

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')
@@ -41,12 +35,33 @@ module Fastlane
         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)
@@ -139,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,

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/helper/s3_client_helper.rb

@@ -1,4 +1,4 @@
-require 'aws-sdk'
+require 'aws-sdk-s3'
 
 module Fastlane
   module Helper

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.143.0'.freeze
+  VERSION = '2.144.0'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/fastlane/swift/Deliverfile.swift

@@ -18,4 +18,4 @@ class Deliverfile: DeliverfileProtocol {
 
 
 
-// Generated with fastlane 2.143.0
+// Generated with fastlane 2.144.0

data/fastlane/swift/Fastlane.swift

@@ -2122,7 +2122,7 @@ func copyArtifacts(keepOriginal: Bool = true,
 }
 
 /**
- Upload a new build to [Crashlytics Beta](http://try.crashlytics.com/beta/)
+ Refer to [Firebase App Distribution](https://appdistro.page.link/fastlane-repo)
 
  - parameters:
    - ipaPath: Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action
@@ -2137,6 +2137,10 @@ func copyArtifacts(keepOriginal: Bool = true,
    - notifications: Crashlytics notification option (true/false)
    - debug: Crashlytics debug option (true/false)
 
+ Crashlytics Beta has been deprecated and replaced with Firebase App Distribution.
+ Beta will continue working until May 4, 2020.
+ Check out the [Firebase App Distribution docs](https://github.com/fastlane/fastlane-plugin-firebase_app_distribution) to get started.
+ 
  Additionally, you can specify `notes`, `emails`, `groups` and `notifications`.
  Distributing to Groups: When using the `groups` parameter, it's important to use the group **alias** names for each group you'd like to distribute to. A group's alias can be found in the web UI. If you're viewing the Beta page, you can open the groups dialog by clicking the 'Manage Groups' button.
  This action uses the `submit` binary provided by the Crashlytics framework. If the binary is not found in its usual path, you'll need to specify the path manually by using the `crashlytics_path` option.
@@ -5071,6 +5075,7 @@ func pluginScores(outputPath: String,
    - platforms: Lint against specific platforms (defaults to all platforms supported by the podspec). Multiple platforms must be comma-delimited (available since cocoapods >= 1.6)
    - skipImportValidation: Lint skips validating that the pod can be imported (available since cocoapods >= 1.3)
    - skipTests: Lint skips building and running tests during validation (available since cocoapods >= 1.3)
+   - analyze: Validate with the Xcode Static Analysis tool (available since cocoapods >= 1.6.1)
 
  Test the syntax of your Podfile by linting the pod against the files of its directory
 */
@@ -5092,7 +5097,8 @@ func podLibLint(useBundleExec: Bool = true,
                 noSubspecs: Bool = false,
                 platforms: String? = nil,
                 skipImportValidation: Bool = false,
-                skipTests: Bool = false) {
+                skipTests: Bool = false,
+                analyze: Bool = false) {
   let command = RubyCommand(commandID: "", methodName: "pod_lib_lint", className: nil, args: [RubyCommand.Argument(name: "use_bundle_exec", value: useBundleExec),
                                                                                               RubyCommand.Argument(name: "podspec", value: podspec),
                                                                                               RubyCommand.Argument(name: "verbose", value: verbose),
@@ -5111,7 +5117,8 @@ func podLibLint(useBundleExec: Bool = true,
                                                                                               RubyCommand.Argument(name: "no_subspecs", value: noSubspecs),
                                                                                               RubyCommand.Argument(name: "platforms", value: platforms),
                                                                                               RubyCommand.Argument(name: "skip_import_validation", value: skipImportValidation),
-                                                                                              RubyCommand.Argument(name: "skip_tests", value: skipTests)])
+                                                                                              RubyCommand.Argument(name: "skip_tests", value: skipTests),
+                                                                                              RubyCommand.Argument(name: "analyze", value: analyze)])
   _ = runner.executeCommand(command)
 }
 
@@ -5640,6 +5647,7 @@ func rubyVersion() {
    - appIdentifier: The bundle identifier of the app to uninstall (only needed when enabling reinstall_app)
    - onlyTesting: Array of strings matching Test Bundle/Test Suite/Test Cases to run
    - skipTesting: Array of strings matching Test Bundle/Test Suite/Test Cases to skip
+   - testplan: The testplan associated with the scheme that should be used for testing
    - xctestrun: Run tests using the provided `.xctestrun` file
    - toolchain: The toolchain that should be used for building the application (e.g. `com.apple.dt.toolchain.Swift_2_3, org.swift.30p620160816a`)
    - clean: Should the project be cleaned before building it?
@@ -5702,6 +5710,7 @@ func runTests(workspace: String? = nil,
               appIdentifier: String? = nil,
               onlyTesting: Any? = nil,
               skipTesting: Any? = nil,
+              testplan: String? = nil,
               xctestrun: String? = nil,
               toolchain: Any? = nil,
               clean: Bool = false,
@@ -5761,6 +5770,7 @@ func runTests(workspace: String? = nil,
                                                                                            RubyCommand.Argument(name: "app_identifier", value: appIdentifier),
                                                                                            RubyCommand.Argument(name: "only_testing", value: onlyTesting),
                                                                                            RubyCommand.Argument(name: "skip_testing", value: skipTesting),
+                                                                                           RubyCommand.Argument(name: "testplan", value: testplan),
                                                                                            RubyCommand.Argument(name: "xctestrun", value: xctestrun),
                                                                                            RubyCommand.Argument(name: "toolchain", value: toolchain),
                                                                                            RubyCommand.Argument(name: "clean", value: clean),
@@ -5901,6 +5911,7 @@ func say(text: Any,
    - appIdentifier: The bundle identifier of the app to uninstall (only needed when enabling reinstall_app)
    - onlyTesting: Array of strings matching Test Bundle/Test Suite/Test Cases to run
    - skipTesting: Array of strings matching Test Bundle/Test Suite/Test Cases to skip
+   - testplan: The testplan associated with the scheme that should be used for testing
    - xctestrun: Run tests using the provided `.xctestrun` file
    - toolchain: The toolchain that should be used for building the application (e.g. `com.apple.dt.toolchain.Swift_2_3, org.swift.30p620160816a`)
    - clean: Should the project be cleaned before building it?
@@ -5963,6 +5974,7 @@ func scan(workspace: Any? = scanfile.workspace,
           appIdentifier: Any? = scanfile.appIdentifier,
           onlyTesting: Any? = scanfile.onlyTesting,
           skipTesting: Any? = scanfile.skipTesting,
+          testplan: Any? = scanfile.testplan,
           xctestrun: Any? = scanfile.xctestrun,
           toolchain: Any? = scanfile.toolchain,
           clean: Bool = scanfile.clean,
@@ -6022,6 +6034,7 @@ func scan(workspace: Any? = scanfile.workspace,
                                                                                       RubyCommand.Argument(name: "app_identifier", value: appIdentifier),
                                                                                       RubyCommand.Argument(name: "only_testing", value: onlyTesting),
                                                                                       RubyCommand.Argument(name: "skip_testing", value: skipTesting),
+                                                                                      RubyCommand.Argument(name: "testplan", value: testplan),
                                                                                       RubyCommand.Argument(name: "xctestrun", value: xctestrun),
                                                                                       RubyCommand.Argument(name: "toolchain", value: toolchain),
                                                                                       RubyCommand.Argument(name: "clean", value: clean),
@@ -7123,6 +7136,7 @@ func supply(packageName: String,
    - quiet: Don't print status logs like 'Linting <file>' & 'Done linting'
    - executable: Path to the `swiftlint` executable on your machine
    - format: Format code when mode is :autocorrect
+   - noCache: Ignore the cache when mode is :autocorrect or :lint
    - compilerLogPath: Compiler log path when mode is :analyze
 */
 func swiftlint(mode: Any = "lint",
@@ -7137,6 +7151,7 @@ func swiftlint(mode: Any = "lint",
                quiet: Bool = false,
                executable: String? = nil,
                format: Bool = false,
+               noCache: Bool = false,
                compilerLogPath: String? = nil) {
   let command = RubyCommand(commandID: "", methodName: "swiftlint", className: nil, args: [RubyCommand.Argument(name: "mode", value: mode),
                                                                                            RubyCommand.Argument(name: "path", value: path),
@@ -7150,6 +7165,7 @@ func swiftlint(mode: Any = "lint",
                                                                                            RubyCommand.Argument(name: "quiet", value: quiet),
                                                                                            RubyCommand.Argument(name: "executable", value: executable),
                                                                                            RubyCommand.Argument(name: "format", value: format),
+                                                                                           RubyCommand.Argument(name: "no_cache", value: noCache),
                                                                                            RubyCommand.Argument(name: "compiler_log_path", value: compilerLogPath)])
   _ = runner.executeCommand(command)
 }
@@ -7557,6 +7573,42 @@ func updateAppIdentifier(xcodeproj: String,
   _ = runner.executeCommand(command)
 }
 
+/**
+ Configures Xcode's Codesigning options
+
+ - parameters:
+   - path: Path to your Xcode project
+   - useAutomaticSigning: Defines if project should use automatic signing
+   - teamId: Team ID, is used when upgrading project
+   - targets: Specify targets you want to toggle the signing mech. (default to all targets)
+   - codeSignIdentity: Code signing identity type (iPhone Developer, iPhone Distribution)
+   - profileName: Provisioning profile name to use for code signing
+   - profileUuid: Provisioning profile UUID to use for code signing
+   - bundleIdentifier: Application Product Bundle Identifier
+
+ - returns: The current status (boolean) of codesigning after modification
+
+ Configures Xcode's Codesigning options of all targets in the project
+*/
+func updateCodeSigningSettings(path: String,
+                               useAutomaticSigning: Bool = false,
+                               teamId: String? = nil,
+                               targets: [String]? = nil,
+                               codeSignIdentity: String? = nil,
+                               profileName: String? = nil,
+                               profileUuid: String? = nil,
+                               bundleIdentifier: String? = nil) {
+  let command = RubyCommand(commandID: "", methodName: "update_code_signing_settings", className: nil, args: [RubyCommand.Argument(name: "path", value: path),
+                                                                                                              RubyCommand.Argument(name: "use_automatic_signing", value: useAutomaticSigning),
+                                                                                                              RubyCommand.Argument(name: "team_id", value: teamId),
+                                                                                                              RubyCommand.Argument(name: "targets", value: targets),
+                                                                                                              RubyCommand.Argument(name: "code_sign_identity", value: codeSignIdentity),
+                                                                                                              RubyCommand.Argument(name: "profile_name", value: profileName),
+                                                                                                              RubyCommand.Argument(name: "profile_uuid", value: profileUuid),
+                                                                                                              RubyCommand.Argument(name: "bundle_identifier", value: bundleIdentifier)])
+  _ = runner.executeCommand(command)
+}
+
 /**
  Makes sure fastlane-tools are up-to-date when running fastlane
 
@@ -8735,4 +8787,4 @@ let snapshotfile: Snapshotfile = Snapshotfile()
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.71]
+// FastlaneRunnerAPIVersion [0.9.72]