fastlane 2.169.0 → 2.174.0

data/deliver/lib/deliver/setup.rb

@@ -46,7 +46,7 @@ module Deliver
       v = app.get_latest_app_store_version(platform: platform)
 
       metadata_path = options[:metadata_path] || File.join(deliver_path, 'metadata')
-      generate_metadata_files(app, v, metadata_path)
+      generate_metadata_files(app, v, metadata_path, options)
 
       # Generate the final Deliverfile here
       return File.read(deliverfile_path)
@@ -60,9 +60,14 @@ module Deliver
       end
     end
 
-    def generate_metadata_files(app, version, path)
+    def generate_metadata_files(app, version, path, options)
       # App info localizations
-      app_info = app.fetch_live_app_info || app.fetch_edit_app_info
+      if options[:use_live_version]
+        app_info = app.fetch_live_app_info
+        UI.user_error!("The option `use_live_version` was set to `true`, however no live app was found on App Store Connect.") unless app_info
+      else
+        app_info = app.fetch_edit_app_info || app.fetch_live_app_info
+      end
       app_info_localizations = app_info.get_app_info_localizations
       app_info_localizations.each do |localization|
         language = localization.locale

data/deliver/lib/deliver/upload_metadata.rb

@@ -1,3 +1,5 @@
+require 'spaceship'
+
 require_relative 'module'
 require_relative 'queue_worker'
 
@@ -375,7 +377,7 @@ module Deliver
       # Check folder list (an empty folder signifies a language is required)
       ignore_validation = options[:ignore_language_directory_validation]
       Loader.language_folders(options[:metadata_path], ignore_validation).each do |lang_folder|
-        enabled_languages << lang_folder.language unless enabled_languages.include?(lang_folder.language)
+        enabled_languages << lang_folder.basename unless enabled_languages.include?(lang_folder.basename)
       end
 
       return unless enabled_languages.include?("default")
@@ -414,7 +416,7 @@ module Deliver
       # Check folder list (an empty folder signifies a language is required)
       ignore_validation = options[:ignore_language_directory_validation]
       Loader.language_folders(options[:metadata_path], ignore_validation).each do |lang_folder|
-        enabled_languages << lang_folder.language unless enabled_languages.include?(lang_folder.language)
+        enabled_languages << lang_folder.basename unless enabled_languages.include?(lang_folder.basename)
       end
 
       # Mapping to strings because :default symbol can be passed in
@@ -531,7 +533,7 @@ module Deliver
 
           UI.message("Loading '#{path}'...")
           options[key] ||= {}
-          options[key][lang_folder.language] ||= File.read(path)
+          options[key][lang_folder.basename] ||= File.read(path)
         end
       end
 

data/fastlane/lib/fastlane/actions/add_git_tag.rb

@@ -9,7 +9,10 @@ module Fastlane
         if options[:tag]
           tag = options[:tag]
         elsif options[:build_number]
-          tag = "#{options[:grouping]}/#{lane_name}/#{options[:prefix]}#{options[:build_number]}#{options[:postfix]}"
+          tag_components = [options[:grouping]]
+          tag_components << lane_name if options[:includes_lane]
+          tag_components << "#{options[:prefix]}#{options[:build_number]}#{options[:postfix]}"
+          tag = tag_components.join('/')
         else
           UI.user_error!("No value found for 'tag' or 'build_number'. At least one of them must be provided. Note that if you do specify a tag, all other arguments are ignored.")
         end
@@ -34,14 +37,14 @@ module Fastlane
       def self.details
         list = <<-LIST.markdown_list
           `grouping` is just to keep your tags organised under one 'folder', defaults to 'builds'
-          `lane` is the name of the current fastlane lane
+          `lane` is the name of the current fastlane lane, if chosen to be included via 'includes_lane' option, which defaults to 'true'
           `prefix` is anything you want to stick in front of the version number, e.g. 'v'
           `postfix` is anything you want to stick at the end of the version number, e.g. '-RC1'
           `build_number` is the build number, which defaults to the value emitted by the `increment_build_number` action
         LIST
 
         [
-          "This will automatically tag your build with the following format: `<grouping>/<lane>/<prefix><build_number>`, where:".markdown_preserve_newlines,
+          "This will automatically tag your build with the following format: `<grouping>/<lane>/<prefix><build_number><postfix>`, where:".markdown_preserve_newlines,
           list,
           "For example, for build 1234 in the 'appstore' lane, it will tag the commit with `builds/appstore/1234`."
         ].join("\n")
@@ -57,6 +60,11 @@ module Fastlane
                                        env_name: "FL_GIT_TAG_GROUPING",
                                        description: "Is used to keep your tags organised under one 'folder'",
                                        default_value: 'builds'),
+          FastlaneCore::ConfigItem.new(key: :includes_lane,
+                                       env_name: "FL_GIT_TAG_INCLUDES_LANE",
+                                       description: "Whether the current lane should be included in the tag and message composition, e.g. '<grouping>/<lane>/<prefix><build_number><postfix>'",
+                                       is_string: false,
+                                       default_value: true),
           FastlaneCore::ConfigItem.new(key: :prefix,
                                        env_name: "FL_GIT_TAG_PREFIX",
                                        description: "Anything you want to put in front of the version number (e.g. 'v')",
@@ -102,6 +110,7 @@ module Fastlane
           'add_git_tag # simple tag with default values',
           'add_git_tag(
             grouping: "fastlane-builds",
+            includes_lane: true,
             prefix: "v",
             postfix: "-RC1",
             build_number: 123

data/fastlane/lib/fastlane/actions/app_store_connect_api_key.rb

@@ -75,6 +75,7 @@ module Fastlane
                                        env_name: "APP_STORE_CONNECT_API_KEY_DURATION",
                                        description: "The token session duration",
                                        optional: true,
+                                       default_value: Spaceship::ConnectAPI::Token::MAX_TOKEN_DURATION,
                                        type: Integer),
           FastlaneCore::ConfigItem.new(key: :in_house,
                                        env_name: "APP_STORE_CONNECT_API_KEY_IN_HOUSE",

data/fastlane/lib/fastlane/actions/appetize.rb

@@ -31,6 +31,10 @@ module Fastlane
 
         params[:note] = options[:note] if options[:note].to_s.length > 0
 
+        if options[:timeout]
+          params[:timeout] = options[:timeout]
+        end
+
         uri = URI.parse(appetize_url(options))
         req = create_request(uri, params)
         req.basic_auth(options[:api_token], nil)
@@ -147,7 +151,15 @@ module Fastlane
                                        env_name: "APPETIZE_NOTE",
                                        description: "Notes you wish to add to the uploaded app",
                                        is_string: true,
-                                       optional: true)
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "APPETIZE_TIMEOUT",
+                                       description: "The number of seconds to wait until automatically ending the session due to user inactivity. Must be 30, 60, 90, 120, 180, 300, 600, 1800, 3600 or 7200. Default is 120",
+                                       type: Integer,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The value provided doesn't match any of the supported options.") unless [30, 60, 90, 120, 180, 300, 600, 1800, 3600, 7200].include?(value)
+                                       end)
         ]
       end
 

data/fastlane/lib/fastlane/actions/artifactory.rb

@@ -10,7 +10,12 @@ module Fastlane
         Actions.verify_gem!('artifactory')
 
         require 'artifactory'
+
+        UI.user_error!("Cannot connect to Artifactory - 'username' was provided but it's missing 'password'") if params[:username] && !params[:password]
+        UI.user_error!("Cannot connect to Artifactory - 'password' was provided but it's missing 'username'") if !params[:username] && params[:password]
+        UI.user_error!("Cannot connect to Artifactory - either 'api_key', or 'username' and 'password' must be provided") if !params[:api_key] && !params[:username]
         file_path = File.absolute_path(params[:file])
+
         if File.exist?(file_path)
           client = connect_to_artifactory(params)
           artifact = Artifactory::Resource::Artifact.new
@@ -37,7 +42,7 @@ module Fastlane
       end
 
       def self.connect_to_artifactory(params)
-        config_keys = [:endpoint, :username, :password, :ssl_pem_file, :ssl_verify, :proxy_username, :proxy_password, :proxy_address, :proxy_port, :read_timeout]
+        config_keys = [:endpoint, :username, :password, :api_key, :ssl_pem_file, :ssl_verify, :proxy_username, :proxy_password, :proxy_address, :proxy_port, :read_timeout]
         config = params.values.select do |key|
           config_keys.include?(key)
         end
@@ -48,6 +53,10 @@ module Fastlane
         'This action uploads an artifact to artifactory'
       end
 
+      def self.details
+        'Connect to the artifactory server using either a username/password or an api_key'
+      end
+
       def self.is_supported?(platform)
         true
       end
@@ -72,6 +81,13 @@ module Fastlane
             file: "example.ipa",                                # File to upload
             repo: "mobile_artifacts",                           # Artifactory repo
             repo_path: "/ios/appname/example-major.minor.ipa"   # Path to place the artifact including its filename
+          )',
+          'artifactory(
+            api_key: "api_key",
+            endpoint: "https://artifactory.example.com/artifactory/",
+            file: "example.ipa",                                # File to upload
+            repo: "mobile_artifacts",                           # Artifactory repo
+            repo_path: "/ios/appname/example-major.minor.ipa"   # Path to place the artifact including its filename
           )'
         ]
       end
@@ -101,12 +117,29 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :username,
                                        env_name: "FL_ARTIFACTORY_USERNAME",
                                        description: "Artifactory username",
-                                       optional: false),
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'username'")
+                                       end),
           FastlaneCore::ConfigItem.new(key: :password,
                                        env_name: "FL_ARTIFACTORY_PASSWORD",
                                        description: "Artifactory password",
                                        sensitive: true,
-                                       optional: false),
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'password'")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "FL_ARTIFACTORY_API_KEY",
+                                       description: "Artifactory API key",
+                                       sensitive: true,
+                                       optional: true,
+                                       conflicting_options: [:username, :password],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'api_key'")
+                                       end),
           FastlaneCore::ConfigItem.new(key: :properties,
                                        env_name: "FL_ARTIFACTORY_PROPERTIES",
                                        description: "Artifact properties hash",

data/fastlane/lib/fastlane/actions/build_and_upload_to_appetize.rb

@@ -21,7 +21,8 @@ module Fastlane
         other_action.appetize(path: zipped_bundle,
                               api_token: params[:api_token],
                               public_key: params[:public_key],
-                              note: params[:note])
+                              note: params[:note],
+                              timeout: params[:timeout])
 
         public_key = Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY]
         UI.success("Generated Public Key: #{Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY]}")
@@ -76,7 +77,14 @@ module Fastlane
           FastlaneCore::ConfigItem.new(key: :note,
                                        description: "Notes you wish to add to the uploaded app",
                                        is_string: true,
-                                       optional: true)
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       description: "The number of seconds to wait until automatically ending the session due to user inactivity. Must be 30, 60, 90, 120, 180, 300, 600, 1800, 3600 or 7200. Default is 120",
+                                       type: Integer,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The value provided doesn't match any of the supported options.") unless [30, 60, 90, 120, 180, 300, 600, 1800, 3600, 7200].include?(value)
+                                       end)
         ]
       end
 

data/fastlane/lib/fastlane/actions/build_app.rb

@@ -8,6 +8,7 @@ module Fastlane
     end
 
     class BuildAppAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.run(values)
         require 'gym'
 
@@ -50,7 +51,8 @@ module Fastlane
               begin
                 profile = FastlaneCore::ProvisioningProfile.parse(profile_path)
                 app_id_prefix = profile["ApplicationIdentifierPrefix"].first
-                bundle_id = profile["Entitlements"]["application-identifier"].gsub("#{app_id_prefix}.", "")
+                entitlements = profile["Entitlements"]
+                bundle_id = (entitlements["application-identifier"] || entitlements["com.apple.application-identifier"]).gsub("#{app_id_prefix}.", "")
                 values[:export_options][:provisioningProfiles][bundle_id] = profile["Name"]
               rescue => ex
                 UI.error("Couldn't load profile at path: #{profile_path}")

data/fastlane/lib/fastlane/actions/carthage.rb

@@ -33,6 +33,8 @@ module Fastlane
         cmd << "--cache-builds" if params[:cache_builds]
         cmd << "--new-resolver" if params[:new_resolver]
         cmd << "--log-path #{params[:log_path]}" if params[:log_path]
+        cmd << "--use-xcframeworks" if params[:use_xcframeworks]
+        cmd << "--archive" if params[:archive]
 
         Actions.sh(cmd.join(' '))
       end
@@ -50,6 +52,14 @@ module Fastlane
         if params[:log_path] && !%w(build bootstrap update).include?(command_name)
           UI.user_error!("Log path option is available only for 'build', 'bootstrap', and 'update' command.")
         end
+
+        if params[:use_xcframeworks] && !%w(build bootstrap update).include?(command_name)
+          UI.user_error!("Use XCFrameworks option is available only for 'build', 'bootstrap', and 'update' command.")
+        end
+
+        if command_name != "build" && params[:archive]
+          UI.user_error!("Archive option is available only for 'build' command.")
+        end
       end
 
       def self.description
@@ -183,6 +193,18 @@ module Fastlane
                                        env_name: "FL_CARTHAGE_LOG_PATH",
                                        description: "Path to the xcode build output",
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_xcframeworks,
+                                       env_name: "FL_CARTHAGE_USE_XCFRAMEWORKS",
+                                       description: "Create xcframework bundles instead of one framework per platform (requires Xcode 12+)",
+                                       type: Boolean,
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :archive,
+                                       env_name: "FL_CARTHAGE_ARCHIVE",
+                                       description: "Archive built frameworks from the current project",
+                                       is_string: false,
+                                       type: Boolean,
+                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :executable,
                                        env_name: "FL_CARTHAGE_EXECUTABLE",
                                        description: "Path to the `carthage` executable on your machine",

data/fastlane/lib/fastlane/actions/cocoapods.rb

@@ -1,6 +1,7 @@
 module Fastlane
   module Actions
     class CocoapodsAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
       def self.run(params)
         Actions.verify_gem!('cocoapods')
         cmd = []
@@ -19,7 +20,8 @@ module Fastlane
 
         cmd << '--no-clean' unless params[:clean]
         cmd << '--no-integrate' unless params[:integrate]
-        cmd << '--clean-install' if params[:clean_install] && pod_version(params).to_f >= 1.7
+        cmd << '--clean-install' if params[:clean_install] && pod_version_at_least("1.7", params)
+        cmd << '--allow-root' if params[:allow_root] && pod_version_at_least("1.10", params)
         cmd << '--repo-update' if params[:repo_update]
         cmd << '--silent' if params[:silent]
         cmd << '--verbose' if params[:verbose]
@@ -46,6 +48,11 @@ module Fastlane
         use_bundle_exec?(params) ? `bundle exec pod --version` : `pod --version`
       end
 
+      def self.pod_version_at_least(at_least_version, params)
+        version = pod_version(params)
+        return Gem::Version.new(version) >= Gem::Version.new(at_least_version)
+      end
+
       def self.call_error_callback(params, result)
         if params[:error_callback]
           Dir.chdir(FastlaneCore::FastlaneFolder.path) do
@@ -120,6 +127,13 @@ module Fastlane
                                        is_string: false,
                                        default_value: false,
                                        type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :allow_root,
+                                       env_name: "FL_COCOAPODS_ALLOW_ROOT",
+                                       description: 'Allows CocoaPods to run as root',
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       type: Boolean),
 
           # Deprecated
           FastlaneCore::ConfigItem.new(key: :clean,

data/fastlane/lib/fastlane/actions/create_pull_request.rb

@@ -20,6 +20,7 @@ module Fastlane
         GithubApiAction.run(
           server_url: params[:api_url],
           api_token: params[:api_token],
+          api_bearer: params[:api_bearer],
           http_method: 'POST',
           path: "repos/#{params[:repo]}/pulls",
           body: payload,
@@ -60,6 +61,7 @@ module Fastlane
         GithubApiAction.run(
           server_url: params[:api_url],
           api_token: params[:api_token],
+          api_bearer: params[:api_bearer],
           http_method: 'PATCH',
           path: "repos/#{params[:repo]}/issues/#{number}",
           body: payload,
@@ -79,6 +81,7 @@ module Fastlane
         GithubApiAction.run(
           server_url: params[:api_url],
           api_token: params[:api_token],
+          api_bearer: params[:api_bearer],
           http_method: 'POST',
           path: "repos/#{params[:repo]}/issues/#{number}/assignees",
           body: payload,
@@ -103,6 +106,7 @@ module Fastlane
         GithubApiAction.run(
           server_url: params[:api_url],
           api_token: params[:api_token],
+          api_bearer: params[:api_bearer],
           http_method: 'POST',
           path: "repos/#{params[:repo]}/pulls/#{number}/requested_reviewers",
           body: payload,
@@ -124,6 +128,7 @@ module Fastlane
         GithubApiAction.run(
           server_url: params[:api_url],
           api_token: params[:api_token],
+          api_bearer: params[:api_bearer],
           http_method: 'PATCH',
           path: "repos/#{params[:repo]}/issues/#{number}",
           body: payload,
@@ -161,7 +166,17 @@ module Fastlane
                                        default_value: ENV["GITHUB_API_TOKEN"],
                                        default_value_dynamic: true,
                                        is_string: true,
-                                       optional: false),
+                                       conflicting_options: [:api_bearer],
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :api_bearer,
+                                       env_name: "GITHUB_PULL_REQUEST_API_BEARER",
+                                       description: "Use a Bearer authorization token. Usually generated by Github Apps, e.g. GitHub Actions GITHUB_TOKEN environment variable",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       conflicting_options: [:api_token],
+                                       optional: true,
+                                       default_value: nil),
           FastlaneCore::ConfigItem.new(key: :repo,
                                        env_name: "GITHUB_PULL_REQUEST_REPO",
                                        description: "The name of the repository you want to submit the pull request to",

data/fastlane/lib/fastlane/actions/create_xcframework.rb

@@ -0,0 +1,118 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      XCFRAMEWORK_PATH ||= :XCFRAMEWORK_PATH
+    end
+
+    class CreateXcframeworkAction < Action
+      def self.run(params)
+        UI.user_error!("Please provide either :frameworks or :libraries to be packaged into the xcframework") unless params[:frameworks] || params[:libraries]
+
+        create_command = ['xcodebuild', '-create-xcframework']
+        create_command << params[:frameworks].map { |framework| ['-framework', "\"#{framework}\""] }.flatten if params[:frameworks]
+        create_command << params[:libraries].map { |library, headers| ['-library', "\"#{library}\""] + (headers.empty? ? [] : ['-headers', "\"#{headers}\""]) } if params[:libraries]
+        create_command << ['-output', "\"#{params[:output]}\""]
+        create_command << ['-allow-internal-distribution'] if params[:allow_internal_distribution]
+
+        Actions.lane_context[SharedValues::XCFRAMEWORK_PATH] = params[:output]
+
+        sh(create_command)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Package multiple build configs of a library/framework into a single xcframework"
+      end
+
+      def self.details
+        <<~DETAILS
+          Utility for packaging multiple build configurations of a given library
+          or framework into a single xcframework.
+
+          If you want to package several frameworks just provide an array containing
+          the list of frameworks to be packaged using the :frameworks parameter.
+
+          If you want to package several libraries with their corresponding headers
+          provide a hash containing the library as the key and the directory containing
+          its headers as the value (or an empty string if there are no headers associated
+          with the provided library).
+
+          Finally specify the location of the xcframework to be generated using the :output
+          parameter.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :frameworks,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_FRAMEWORKS",
+                                       description: "Frameworks to add to the target xcframework",
+                                       type: Array,
+                                       optional: true,
+                                       conflicting_options: [:libraries],
+                                       verify_block: proc do |value|
+                                         value.each do |framework|
+                                           UI.user_error!("#{framework} doesn't end with '.framework'. Is this really a framework?") unless framework.end_with?('.framework')
+                                           UI.user_error!("Couldn't find framework at #{framework}") unless File.exist?(framework)
+                                           UI.user_error!("#{framework} doesn't seem to be a framework") unless File.directory?(framework)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :libraries,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_LIBRARIES",
+                                       description: "Libraries to add to the target xcframework, with their corresponding headers",
+                                       type: Hash,
+                                       optional: true,
+                                       conflicting_options: [:frameworks],
+                                       verify_block: proc do |value|
+                                         value.each do |library, headers|
+                                           UI.user_error!("Couldn't find library at #{library}") unless File.exist?(library)
+                                           UI.user_error!("#{headers} doesn't exist or is not a directory") unless headers.empty? || File.directory?(headers)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :output,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_OUTPUT",
+                                       description: "The path to write the xcframework to",
+                                       type: String,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :allow_internal_distribution,
+                                       env_name: "FL_CREATE_XCFRAMEWORK_ALLOW_INTERNAL_DISTRIBUTION",
+                                       description: "Specifies that the created xcframework contains information not suitable for public distribution",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['XCFRAMEWORK_PATH', 'Location of the generated xcframework']
+        ]
+      end
+
+      def self.return_value
+      end
+
+      def self.example_code
+        [
+          "create_xcframework(frameworks: ['FrameworkA.framework', 'FrameworkB.framework'], output: 'UniversalFramework.xcframework')",
+          "create_xcframework(libraries: { 'LibraryA.so' => '', 'LibraryB.so' => 'LibraryBHeaders'}, output: 'UniversalFramework.xcframework')"
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.authors
+        ["jgongo"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end