fastlane_hotfix 2.187.0

data/fastlane_core/lib/fastlane_core/keychain_importer.rb

@@ -0,0 +1,120 @@
+require_relative 'helper'
+require 'open3'
+require 'security'
+
+module FastlaneCore
+  class KeychainImporter
+    def self.import_file(path, keychain_path, keychain_password: nil, certificate_password: "", skip_set_partition_list: false, output: FastlaneCore::Globals.verbose?)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      command = "security import #{path.shellescape} -k '#{keychain_path.shellescape}'"
+      command << " -P #{certificate_password.shellescape}"
+      command << " -T /usr/bin/codesign" # to not be asked for permission when running a tool like `gym` (before Sierra)
+      command << " -T /usr/bin/security"
+      command << " -T /usr/bin/productbuild" # to not be asked for permission when using an installer cert for macOS
+      command << " 1> /dev/null" unless output
+
+      UI.command(command) if output
+      Open3.popen3(command) do |stdin, stdout, stderr, thrd|
+        UI.command_output(stdout.read.to_s) if output
+
+        # Set partition list only if success since it can be a time consuming process if a lot of keys are installed
+        if thrd.value.success? && !skip_set_partition_list
+          keychain_password ||= resolve_keychain_password(keychain_path)
+          set_partition_list(path, keychain_path, keychain_password: keychain_password, output: output)
+        else
+          # Output verbose if file is already installed since not an error otherwise we will show the whole error
+          err = stderr.read.to_s.strip
+          if err.include?("SecKeychainItemImport") && err.include?("The specified item already exists in the keychain")
+            UI.verbose("'#{File.basename(path)}' is already installed on this machine")
+          else
+            UI.error(err)
+          end
+        end
+      end
+    end
+
+    def self.set_partition_list(path, keychain_path, keychain_password: nil, output: FastlaneCore::Globals.verbose?)
+      # When security supports partition lists, also add the partition IDs
+      # See https://openradar.appspot.com/28524119
+      if Helper.backticks('security -h | grep set-key-partition-list', print: false).length > 0
+        command = "security set-key-partition-list"
+        command << " -S apple-tool:,apple:,codesign:"
+        command << " -s" # This is a needed in Catalina to prevent "security: SecKeychainItemCopyAccess: A missing value was detected."
+        command << " -k #{keychain_password.to_s.shellescape}"
+        command << " #{keychain_path.shellescape}"
+        command << " 1> /dev/null" # always disable stdout. This can be very verbose, and leak potentially sensitive info
+
+        # Showing loading indicator as this can take some time if a lot of keys installed
+        Helper.show_loading_indicator("Setting key partition list... (this can take a minute if there are a lot of keys installed)")
+
+        UI.command(command) if output
+        Open3.popen3(command) do |stdin, stdout, stderr, thrd|
+          unless thrd.value.success?
+            err = stderr.read.to_s.strip
+
+            # Inform user when no/wrong password was used as its needed to prevent UI permission popup from Xcode when signing
+            if err.include?("SecKeychainItemSetAccessWithPassword")
+              keychain_name = File.basename(keychain_path, ".*")
+              Security::InternetPassword.delete(server: server_name(keychain_name))
+
+              UI.important("")
+              UI.important("Could not configure imported keychain item (certificate) to prevent UI permission popup when code signing\n" \
+                       "Check if you supplied the correct `keychain_password` for keychain: `#{keychain_path}`\n" \
+                       "#{err}")
+              UI.important("")
+              UI.important("Please look at the following docs to see how to set a keychain password:")
+              UI.important(" - https://docs.fastlane.tools/actions/sync_code_signing")
+              UI.important(" - https://docs.fastlane.tools/actions/get_certificates")
+            else
+              UI.error(err)
+            end
+          end
+        end
+
+        # Hiding after Open3 finishes
+        Helper.hide_loading_indicator
+
+      end
+    end
+
+    # https://github.com/fastlane/fastlane/issues/14196
+    # Keychain password is needed to set the partition list to
+    # prevent Xcode from prompting dialog for keychain password when signing
+    # 1. Uses keychain password from login keychain if found
+    # 2. Prompts user for keychain password and stores it in login keychain for user later
+    def self.resolve_keychain_password(keychain_path)
+      keychain_name = File.basename(keychain_path, ".*")
+      server = server_name(keychain_name)
+
+      # Attempt to find password in keychain for keychain
+      item = Security::InternetPassword.find(server: server)
+      if item
+        keychain_password = item.password
+        UI.important("Using keychain password from keychain item #{server} in #{keychain_path}")
+      end
+
+      if keychain_password.nil?
+        if UI.interactive?
+          UI.important("Enter the password for #{keychain_path}")
+          UI.important("This passphrase will be stored in your local keychain with the name #{server} and used in future runs")
+          UI.important("This prompt can be avoided by specifying the 'keychain_password' option or 'MATCH_KEYCHAIN_PASSWORD' environment variable")
+          keychain_password = FastlaneCore::Helper.ask_password(message: "Password for #{keychain_name} keychain: ", confirm: true, confirmation_message: "Type password for #{keychain_name} keychain again: ")
+          Security::InternetPassword.add(server, "", keychain_password)
+        else
+          UI.important("Keychain password for #{keychain_path} was not specified and not found in your keychain. Specify the 'keychain_password' option to prevent the UI permission popup when code signing")
+          keychain_password = ""
+        end
+      end
+
+      return keychain_password
+    end
+
+    # server name used for accessing the macOS keychain
+    def self.server_name(keychain_name)
+      ["fastlane", "keychain", keychain_name].join("_")
+    end
+
+    private_class_method :server_name
+  end
+end

data/fastlane_core/lib/fastlane_core/languages.rb

@@ -0,0 +1,16 @@
+module FastlaneCore
+  module Languages
+    # These are all the languages which are available to use to upload app metadata and screenshots
+
+    # The old format which was used until August 2015 (good old times)
+    ALL_LANGUAGES_LEGACY = %w[da-DK de-DE el-GR en-AU en-CA en-GB en-US es-ES es-MX fi-FI fr-CA fr-FR id-ID it-IT ja-JP ko-KR ms-MY nl-NL no-NO pt-BR pt-PT ru-RU sv-SE th-TH tr-TR vi-VI cmn-Hans cmn-Hant]
+
+    # The new format used from September 2015 on
+    # This was generated from `Spaceship::Tunes.client.available_languages.sort`
+    # Updates should also be made to:
+    # - produce/lib/produce/available_default_languages.rb
+    # - spaceship/lib/assets/languageMapping.json
+    # See pull request for example: https://github.com/fastlane/fastlane/pull/14110
+    ALL_LANGUAGES = %w[ar-SA ca cs da de-DE el en-AU en-CA en-GB en-US es-ES es-MX fi fr-CA fr-FR he hi hr hu id it ja ko ms nl-NL no pl pt-BR pt-PT ro ru sk sv th tr uk vi zh-Hans zh-Hant]
+  end
+end

data/fastlane_core/lib/fastlane_core/module.rb

@@ -0,0 +1,31 @@
+require 'fastlane/boolean'
+
+require_relative 'analytics/analytics_session'
+
+module FastlaneCore
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+  Boolean = Fastlane::Boolean
+
+  # Session is used to report usage metrics.
+  # If you opt out, we will not send anything.
+  # You can confirm this by observing how we use the environment variable: FASTLANE_OPT_OUT_USAGE
+  # Specifically, in AnalyticsSession.finalize_session
+  # Learn more at https://docs.fastlane.tools/#metrics
+  def self.session
+    @session ||= AnalyticsSession.new
+  end
+
+  def self.reset_session
+    @session = nil
+  end
+
+  # A directory that's being used to user-wide fastlane configs
+  # This directory is also used for the bundled fastlane
+  # Since we don't want to access FastlaneCore from spaceship
+  # this method is duplicated in spaceship/client.rb
+  def self.fastlane_user_dir
+    path = File.expand_path(File.join(Dir.home, ".fastlane"))
+    FileUtils.mkdir_p(path) unless File.directory?(path)
+    return path
+  end
+end

data/fastlane_core/lib/fastlane_core/pkg_file_analyser.rb

@@ -0,0 +1,51 @@
+require 'rexml/document'
+
+require_relative 'helper'
+
+module FastlaneCore
+  class PkgFileAnalyser
+    def self.fetch_app_identifier(path)
+      xml = self.fetch_distribution_xml_file(path)
+      return xml.elements['installer-gui-script/product'].attributes['id'] if xml
+      return nil
+    end
+
+    # Fetches the app version from the given pkg file.
+    def self.fetch_app_version(path)
+      xml = self.fetch_distribution_xml_file(path)
+      return xml.elements['installer-gui-script/product'].attributes['version'] if xml
+      return nil
+    end
+
+    # Fetches the app version from the given pkg file.
+    def self.fetch_app_build(path)
+      xml = self.fetch_distribution_xml_file(path)
+      return xml.elements['installer-gui-script/pkg-ref/bundle-version/bundle'].attributes['CFBundleVersion'] if xml
+      return nil
+    end
+
+    def self.fetch_distribution_xml_file(path)
+      Dir.mktmpdir do |dir|
+        Helper.backticks("xar -C #{dir.shellescape} -xf #{path.shellescape}")
+
+        Dir.foreach(dir) do |file|
+          next unless file.include?('Distribution')
+
+          begin
+            content = File.open(File.join(dir, file))
+            xml = REXML::Document.new(content)
+
+            if xml.elements['installer-gui-script/product']
+              return xml
+            end
+          rescue => ex
+            UI.error(ex)
+            UI.error("Error parsing *.pkg distribution xml #{File.join(dir, file)}")
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/pkg_upload_package_builder.rb

@@ -0,0 +1,49 @@
+require 'digest/md5'
+require 'securerandom'
+
+require_relative 'globals'
+require_relative 'ui/ui'
+require_relative 'module'
+
+module FastlaneCore
+  # Builds a package for the pkg ready to be uploaded with the iTunes Transporter
+  class PkgUploadPackageBuilder
+    METADATA_FILE_NAME = 'metadata.xml'
+
+    attr_accessor :package_path
+
+    def generate(app_id: nil, pkg_path: nil, package_path: nil, platform: "osx")
+      self.package_path = File.join(package_path, "#{app_id}-#{SecureRandom.uuid}.itmsp")
+      FileUtils.rm_rf(self.package_path) if File.directory?(self.package_path)
+      FileUtils.mkdir_p(self.package_path)
+
+      pkg_path = copy_pkg(pkg_path)
+      @data = {
+        apple_id: app_id,
+        file_size: File.size(pkg_path),
+        ipa_path: File.basename(pkg_path), # this is only the base name as the ipa is inside the package
+        md5: Digest::MD5.hexdigest(File.read(pkg_path)),
+        archive_type: 'product-archive',
+        platform: platform
+      }
+
+      xml_path = File.join(FastlaneCore::ROOT, 'lib/assets/XMLTemplate.xml.erb')
+      xml = ERB.new(File.read(xml_path)).result(binding) # https://web.archive.org/web/20160430190141/www.rrn.dk/rubys-erb-templating-system
+
+      File.write(File.join(self.package_path, METADATA_FILE_NAME), xml)
+      UI.success("Wrote XML data to '#{self.package_path}'") if FastlaneCore::Globals.verbose?
+
+      return self.package_path
+    end
+
+    private
+
+    def copy_pkg(pkg_path)
+      ipa_file_name = Digest::MD5.hexdigest(pkg_path)
+      resulting_path = File.join(self.package_path, "#{ipa_file_name}.pkg")
+      FileUtils.cp(pkg_path, resulting_path)
+
+      resulting_path
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/print_table.rb

@@ -0,0 +1,133 @@
+require_relative 'configuration/configuration'
+require_relative 'helper'
+
+module FastlaneCore
+  class PrintTable
+    class << self
+      # This method prints out all the user inputs in a nice table. Useful to summarize the run
+      # You can pass an array to `hide_keys` if you don't want certain elements to show up (symbols or strings)
+      # You can pass an array to `mask_keys` if you want to mask certain elements (symbols or strings)
+      def print_values(config: nil, title: nil, hide_keys: [], mask_keys: [], transform: :newline)
+        require 'terminal-table'
+
+        options = {}
+        unless config.nil?
+          if config.kind_of?(FastlaneCore::Configuration)
+            # find sensitive options and mask them by default
+            config.available_options.each do |config_item|
+              if config_item.sensitive
+                mask_keys << config_item.key.to_s
+              end
+            end
+            options = config.values(ask: false)
+          else
+            options = config
+          end
+        end
+        rows = self.collect_rows(options: options, hide_keys: hide_keys.map(&:to_s), mask_keys: mask_keys.map(&:to_s), prefix: '')
+
+        params = {}
+
+        if transform
+          params[:rows] = transform_output(rows, transform: transform)
+        else
+          params[:rows] = rows
+        end
+
+        params[:title] = title.green if title
+
+        unless FastlaneCore::Env.truthy?("FASTLANE_SKIP_ALL_LANE_SUMMARIES")
+          puts("")
+          puts(Terminal::Table.new(params))
+          puts("")
+        end
+
+        return params
+      end
+
+      def colorize_array(array, colors)
+        value = ""
+        array.each do  |l|
+          colored_line = l
+          colored_line = "#{colors.first}#{l}#{colors.last}" if colors.length > 0
+          value << colored_line
+          value << "\n"
+        end
+        return value
+      end
+
+      def should_transform?
+        if FastlaneCore::Helper.ci? || FastlaneCore::Helper.test?
+          return false
+        end
+        return !FastlaneCore::Env.truthy?("FL_SKIP_TABLE_TRANSFORM")
+      end
+
+      def transform_row(column, transform, max_value_length)
+        return column if column.nil? # we want to keep the nil and not convert it to a string
+        return column if transform.nil?
+
+        value = column.to_s.dup
+
+        if transform == :truncate_middle
+          return value.middle_truncate(max_value_length)
+        elsif transform == :newline
+          # remove all fixed newlines as it may mess up the output
+          value.gsub!("\n", " ") if value.kind_of?(String)
+          if value.length >= max_value_length
+            colors = value.scan(/\e\[.*?m/)
+            colors.each { |color| value.gsub!(color, '') }
+            lines = value.wordwrap(max_value_length)
+            return  colorize_array(lines, colors)
+          end
+        elsif transform
+          UI.user_error!("Unknown transform value '#{transform}'")
+        end
+        return value
+      end
+
+      def transform_output(rows, transform: :newline)
+        return rows unless should_transform?
+
+        require 'fastlane_core/string_filters'
+        require 'tty-screen'
+
+        number_of_cols = TTY::Screen.width
+
+        col_count = rows.map(&:length).first || 1
+
+        # -4 per column - as tt adds "| " and " |"
+        terminal_table_padding = 4
+        max_length = number_of_cols - (col_count * terminal_table_padding)
+
+        max_value_length = (max_length / col_count) - 1
+
+        return_array = rows.map do |row|
+          row.map do |column|
+            transform_row(column, transform, max_value_length)
+          end
+        end
+        return return_array
+      end
+
+      def collect_rows(options: nil, hide_keys: [], mask_keys: [], prefix: '', mask: '********')
+        rows = []
+
+        options.each do |key, value|
+          prefixed_key = "#{prefix}#{key}"
+          next if value.nil?
+          next if value.to_s == ""
+          next if hide_keys.include?(prefixed_key)
+          value = mask if mask_keys.include?(prefixed_key)
+
+          if value.respond_to?(:key)
+            rows.concat(self.collect_rows(options: value, hide_keys: hide_keys, mask_keys: mask_keys, prefix: "#{prefix}#{key}.", mask: mask))
+          else
+            rows << [prefixed_key, value]
+          end
+        end
+        rows
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/project.rb

@@ -0,0 +1,529 @@
+require_relative 'helper'
+require 'xcodeproj'
+require_relative './configuration/configuration'
+require 'fastlane_core/command_executor'
+
+module FastlaneCore
+  # Represents an Xcode project
+  class Project # rubocop:disable Metrics/ClassLength
+    class << self
+      # Project discovery
+      def detect_projects(config)
+        if config[:workspace].to_s.length > 0 && config[:project].to_s.length > 0
+          UI.user_error!("You can only pass either a workspace or a project path, not both")
+        end
+
+        return if config[:project].to_s.length > 0
+
+        if config[:workspace].to_s.length == 0
+          workspace = Dir["./*.xcworkspace"]
+          if workspace.count > 1
+            puts("Select Workspace: ")
+            config[:workspace] = choose(*workspace)
+          elsif !workspace.first.nil?
+            config[:workspace] = workspace.first
+          end
+        end
+
+        return if config[:workspace].to_s.length > 0
+
+        if config[:workspace].to_s.length == 0 && config[:project].to_s.length == 0
+          project = Dir["./*.xcodeproj"]
+          if project.count > 1
+            puts("Select Project: ")
+            config[:project] = choose(*project)
+          elsif !project.first.nil?
+            config[:project] = project.first
+          end
+        end
+
+        if config[:workspace].nil? && config[:project].nil?
+          select_project(config)
+        end
+      end
+
+      def select_project(config)
+        loop do
+          path = UI.input("Couldn't automatically detect the project file, please provide a path: ")
+          if File.directory?(path)
+            if path.end_with?(".xcworkspace")
+              config[:workspace] = path
+              break
+            elsif path.end_with?(".xcodeproj")
+              config[:project] = path
+              break
+            else
+              UI.error("Path must end with either .xcworkspace or .xcodeproj")
+            end
+          else
+            UI.error("Couldn't find project at path '#{File.expand_path(path)}'")
+          end
+        end
+      end
+    end
+
+    # Path to the project/workspace
+    attr_accessor :path
+
+    # Is this project a workspace?
+    attr_accessor :is_workspace
+
+    # @param options [FastlaneCore::Configuration|Hash] a set of configuration to run xcodebuild to work out build settings
+    # @param xcodebuild_list_silent [Boolean] a flag to silent xcodebuild command's output
+    # @param xcodebuild_suppress_stderr [Boolean] a flag to supress output to stderr from xcodebuild
+    def initialize(options)
+      @options = options
+      @path = File.expand_path(self.options[:workspace] || self.options[:project])
+      @is_workspace = (self.options[:workspace].to_s.length > 0)
+
+      if !path || !File.directory?(path)
+        UI.user_error!("Could not find project at path '#{path}'")
+      end
+    end
+
+    # @return [Hash] a hash object containing project, workspace, scheme, any configuration related to xcodebuild, or etc...
+    def options
+      # To keep compatibility with actions using this class from outside of `fastlane` gem; i.e. `xcov`,
+      # converts `options` to a plain Hash. Otherwise, it might crash when a new option's key is added
+      # due to `FastlaneCore::Configuration` to validate valid keys defined.
+      @options.kind_of?(FastlaneCore::Configuration) ? @options.values : @options
+    end
+
+    def options=(new_value)
+      UI.deprecated('Update `options` is not worth doing since it can change behavior of this object entirely. Consider re-creating FastlaneCore::Project.')
+      @options = new_value
+    end
+
+    def workspace?
+      self.is_workspace
+    end
+
+    def project_name
+      if is_workspace
+        return File.basename(options[:workspace], ".xcworkspace")
+      else
+        return File.basename(options[:project], ".xcodeproj")
+      end
+    end
+
+    # returns the Xcodeproj::Workspace or nil if it is a project
+    def workspace
+      return nil unless workspace?
+
+      @workspace ||= Xcodeproj::Workspace.new_from_xcworkspace(path)
+      @workspace
+    end
+
+    # returns the Xcodeproj::Project or nil if it is a workspace
+    def project
+      return nil if workspace?
+      @project ||= Xcodeproj::Project.open(path)
+    end
+
+    # Get all available schemes in an array
+    def schemes
+      @schemes ||= if workspace?
+                     if FastlaneCore::Env.truthy?("FASTLANE_INCLUDE_PODS_PROJECT_SCHEMES")
+                       workspace.schemes.keys
+                     else
+                       workspace.schemes.reject do |k, v|
+                         v.include?("Pods/Pods.xcodeproj")
+                       end.keys
+                     end
+                   else
+                     Xcodeproj::Project.schemes(path)
+                   end
+    end
+
+    # Let the user select a scheme
+    # Use a scheme containing the preferred_to_include string when multiple schemes were found
+    def select_scheme(preferred_to_include: nil)
+      if options[:scheme].to_s.length > 0
+        # Verify the scheme is available
+        unless schemes.include?(options[:scheme].to_s)
+          UI.error("Couldn't find specified scheme '#{options[:scheme]}'. Please make sure that the scheme is shared, see https://developer.apple.com/library/content/documentation/IDEs/Conceptual/xcode_guide-continuous_integration/ConfigureBots.html#//apple_ref/doc/uid/TP40013292-CH9-SW3")
+          options[:scheme] = nil
+        end
+      end
+
+      return if options[:scheme].to_s.length > 0
+
+      if schemes.count == 1
+        options[:scheme] = schemes.last
+      elsif schemes.count > 1
+        preferred = nil
+        if preferred_to_include
+          preferred = schemes.find_all { |a| a.downcase.include?(preferred_to_include.downcase) }
+        end
+
+        if preferred_to_include && preferred.count == 1
+          options[:scheme] = preferred.last
+        elsif automated_scheme_selection? && schemes.include?(project_name)
+          UI.important("Using scheme matching project name (#{project_name}).")
+          options[:scheme] = project_name
+        elsif Helper.ci?
+          UI.error("Multiple schemes found but you haven't specified one.")
+          UI.error("Since this is a CI, please pass one using the `scheme` option")
+          show_scheme_shared_information
+          UI.user_error!("Multiple schemes found")
+        else
+          puts("Select Scheme: ")
+          options[:scheme] = choose(*schemes)
+        end
+      else
+        show_scheme_shared_information
+
+        UI.user_error!("No Schemes found")
+      end
+    end
+
+    def show_scheme_shared_information
+      UI.error("Couldn't find any schemes in this project, make sure that the scheme is shared if you are using a workspace")
+      UI.error("Open Xcode, click on `Manage Schemes` and check the `Shared` box for the schemes you want to use")
+      UI.error("Afterwards make sure to commit the changes into version control")
+    end
+
+    # Get all available configurations in an array
+    def configurations
+      @configurations ||= if workspace?
+                            workspace
+                              .file_references
+                              .map(&:path)
+                              .reject { |p| p.include?("Pods/Pods.xcodeproj") }
+                              .map do |p|
+                                # To maintain backwards compatibility, we
+                                # silently ignore non-existent projects from
+                                # workspaces.
+                                begin
+                                  Xcodeproj::Project.open(p).build_configurations
+                                rescue
+                                  []
+                                end
+                              end
+                              .flatten
+                              .compact
+                              .map(&:name)
+                          else
+                            project.build_configurations.map(&:name)
+                          end
+    end
+
+    # Returns bundle_id and sets the scheme for xcrun
+    def default_app_identifier
+      default_build_settings(key: "PRODUCT_BUNDLE_IDENTIFIER")
+    end
+
+    # Returns app name and sets the scheme for xcrun
+    def default_app_name
+      if is_workspace
+        return default_build_settings(key: "PRODUCT_NAME")
+      else
+        return app_name
+      end
+    end
+
+    def app_name
+      # WRAPPER_NAME: Example.app
+      # WRAPPER_SUFFIX: .app
+      name = build_settings(key: "WRAPPER_NAME")
+
+      return name.gsub(build_settings(key: "WRAPPER_SUFFIX"), "") if name
+      return "App" # default value
+    end
+
+    def dynamic_library?
+      (build_settings(key: "PRODUCT_TYPE") == "com.apple.product-type.library.dynamic")
+    end
+
+    def static_library?
+      (build_settings(key: "PRODUCT_TYPE") == "com.apple.product-type.library.static")
+    end
+
+    def library?
+      (static_library? || dynamic_library?)
+    end
+
+    def framework?
+      (build_settings(key: "PRODUCT_TYPE") == "com.apple.product-type.framework")
+    end
+
+    def application?
+      (build_settings(key: "PRODUCT_TYPE") == "com.apple.product-type.application")
+    end
+
+    def ios_library?
+      ((static_library? or dynamic_library?) && build_settings(key: "PLATFORM_NAME") == "iphoneos")
+    end
+
+    def ios_tvos_app?
+      (ios? || tvos?)
+    end
+
+    def ios_framework?
+      (framework? && build_settings(key: "PLATFORM_NAME") == "iphoneos")
+    end
+
+    def ios_app?
+      (application? && build_settings(key: "PLATFORM_NAME") == "iphoneos")
+    end
+
+    def produces_archive?
+      !(framework? || static_library? || dynamic_library?)
+    end
+
+    def mac_app?
+      (application? && build_settings(key: "PLATFORM_NAME") == "macosx")
+    end
+
+    def mac_library?
+      ((dynamic_library? or static_library?) && build_settings(key: "PLATFORM_NAME") == "macosx")
+    end
+
+    def mac_framework?
+      (framework? && build_settings(key: "PLATFORM_NAME") == "macosx")
+    end
+
+    def supports_mac_catalyst?
+      build_settings(key: "SUPPORTS_MACCATALYST") == "YES" || build_settings(key: "SUPPORTS_UIKITFORMAC") == "YES"
+    end
+
+    def command_line_tool?
+      (build_settings(key: "PRODUCT_TYPE") == "com.apple.product-type.tool")
+    end
+
+    def mac?
+      supported_platforms.include?(:macOS)
+    end
+
+    def tvos?
+      supported_platforms.include?(:tvOS)
+    end
+
+    def ios?
+      supported_platforms.include?(:iOS)
+    end
+
+    def watchos?
+      supported_platforms.include?(:watchOS)
+    end
+
+    def supported_platforms
+      supported_platforms = build_settings(key: "SUPPORTED_PLATFORMS")
+      if supported_platforms.nil?
+        UI.important("Could not read the \"SUPPORTED_PLATFORMS\" build setting, assuming that the project supports iOS only.")
+        return [:iOS]
+      end
+      supported_platforms.split.map do |platform|
+        case platform
+        when "macosx" then :macOS
+        when "iphonesimulator", "iphoneos" then :iOS
+        when "watchsimulator", "watchos" then :watchOS
+        when "appletvsimulator", "appletvos" then :tvOS
+        end
+      end.uniq.compact
+    end
+
+    def xcodebuild_parameters
+      proj = []
+      proj << "-workspace #{options[:workspace].shellescape}" if options[:workspace]
+      proj << "-scheme #{options[:scheme].shellescape}" if options[:scheme]
+      proj << "-project #{options[:project].shellescape}" if options[:project]
+      proj << "-configuration #{options[:configuration].shellescape}" if options[:configuration]
+      proj << "-derivedDataPath #{options[:derived_data_path].shellescape}" if options[:derived_data_path]
+      proj << "-xcconfig #{options[:xcconfig].shellescape}" if options[:xcconfig]
+      proj << "-scmProvider system" if options[:use_system_scm]
+
+      xcode_at_least_11 = FastlaneCore::Helper.xcode_at_least?('11.0')
+      if xcode_at_least_11 && options[:cloned_source_packages_path]
+        proj << "-clonedSourcePackagesDirPath #{options[:cloned_source_packages_path].shellescape}"
+      end
+
+      if xcode_at_least_11 && options[:disable_package_automatic_updates]
+        proj << "-disableAutomaticPackageResolution"
+      end
+
+      return proj
+    end
+
+    #####################################################
+    # @!group Raw Access
+    #####################################################
+
+    def build_xcodebuild_showbuildsettings_command
+      # We also need to pass the workspace and scheme to this command.
+      #
+      # The 'clean' portion of this command was a workaround for an xcodebuild bug with Core Data projects.
+      # This xcodebuild bug is fixed in Xcode 8.3 so 'clean' it's not necessary anymore
+      # See: https://github.com/fastlane/fastlane/pull/5626
+      if FastlaneCore::Helper.xcode_at_least?('8.3')
+        command = "xcodebuild -showBuildSettings #{xcodebuild_parameters.join(' ')}"
+      else
+        command = "xcodebuild clean -showBuildSettings #{xcodebuild_parameters.join(' ')}"
+      end
+      command
+    end
+
+    def build_xcodebuild_resolvepackagedependencies_command
+      return nil if options[:skip_package_dependencies_resolution]
+      command = "xcodebuild -resolvePackageDependencies #{xcodebuild_parameters.join(' ')}"
+      command
+    end
+
+    # Get the build settings for our project
+    # e.g. to properly get the DerivedData folder
+    # @param [String] The key of which we want the value for (e.g. "PRODUCT_NAME")
+    def build_settings(key: nil, optional: true)
+      unless @build_settings
+        if is_workspace
+          if schemes.count == 0
+            UI.user_error!("Could not find any schemes for Xcode workspace at path '#{self.path}'. Please make sure that the schemes you want to use are marked as `Shared` from Xcode.")
+          end
+          options[:scheme] ||= schemes.first
+        end
+
+        # SwiftPM support
+        if FastlaneCore::Helper.xcode_at_least?('11.0')
+          if (command = build_xcodebuild_resolvepackagedependencies_command)
+            UI.important("Resolving Swift Package Manager dependencies...")
+            FastlaneCore::CommandExecutor.execute(
+              command: command,
+              print_all: true,
+              print_command: true
+            )
+          else
+            UI.important("Skipped Swift Package Manager dependencies resolution.")
+          end
+        end
+
+        command = build_xcodebuild_showbuildsettings_command
+
+        # Xcode might hang here and retrying fixes the problem, see fastlane#4059
+        begin
+          timeout = FastlaneCore::Project.xcode_build_settings_timeout
+          retries = FastlaneCore::Project.xcode_build_settings_retries
+          @build_settings = FastlaneCore::Project.run_command(command, timeout: timeout, retries: retries, print: true)
+          if @build_settings.empty?
+            UI.error("Could not read build settings. Make sure that the scheme \"#{options[:scheme]}\" is configured for running by going to Product → Scheme → Edit Scheme…, selecting the \"Build\" section, checking the \"Run\" checkbox and closing the scheme window.")
+          end
+        rescue Timeout::Error
+          raise FastlaneCore::Interface::FastlaneDependencyCausedException.new, "xcodebuild -showBuildSettings timed out after #{retries + 1} retries with a base timeout of #{timeout}." \
+            " You can override the base timeout value with the environment variable FASTLANE_XCODEBUILD_SETTINGS_TIMEOUT," \
+            " and the number of retries with the environment variable FASTLANE_XCODEBUILD_SETTINGS_RETRIES ".red
+        end
+      end
+
+      begin
+        result = @build_settings.split("\n").find do |c|
+          sp = c.split(" = ")
+          next if sp.length == 0
+          sp.first.strip == key
+        end
+        return result.split(" = ").last
+      rescue => ex
+        return nil if optional # an optional value, we really don't care if something goes wrong
+
+        UI.error(caller.join("\n\t"))
+        UI.error("Could not fetch #{key} from project file: #{ex}")
+      end
+
+      nil
+    end
+
+    # Returns the build settings and sets the default scheme to the options hash
+    def default_build_settings(key: nil, optional: true)
+      options[:scheme] ||= schemes.first if is_workspace
+      build_settings(key: key, optional: optional)
+    end
+
+    # @internal to module
+    def self.xcode_build_settings_timeout
+      (ENV['FASTLANE_XCODEBUILD_SETTINGS_TIMEOUT'] || 3).to_i
+    end
+
+    # @internal to module
+    def self.xcode_build_settings_retries
+      (ENV['FASTLANE_XCODEBUILD_SETTINGS_RETRIES'] || 3).to_i
+    end
+
+    # @internal to module
+    # runs the specified command with the specified number of retries, killing each run if it times out.
+    # the first run times out after specified timeout elapses, and each successive run times out after
+    # a doubling of the previous timeout has elapsed.
+    # @raises Timeout::Error if all tries result in a timeout
+    # @returns the output of the command
+    # Note: - currently affected by https://github.com/fastlane/fastlane/issues/1504
+    #       - retry feature added to solve https://github.com/fastlane/fastlane/issues/4059
+    def self.run_command(command, timeout: 0, retries: 0, print: true)
+      require 'timeout'
+
+      UI.command(command) if print
+
+      result = ''
+
+      total_tries = retries + 1
+      try = 1
+      try_timeout = timeout
+      begin
+        Timeout.timeout(try_timeout) do
+          # Using Helper.backticks didn't work here. `Timeout` doesn't time out, and the command hangs forever
+          result = `#{command}`.to_s
+        end
+      rescue Timeout::Error
+        try_limit_reached = try >= total_tries
+
+        # Try harder on each iteration
+        next_timeout = try_timeout * 2
+
+        message = "Command timed out after #{try_timeout} seconds on try #{try} of #{total_tries}"
+        message += ", trying again with a #{next_timeout} second timeout..." unless try_limit_reached
+
+        UI.important(message)
+
+        raise if try_limit_reached
+
+        try += 1
+        try_timeout = next_timeout
+        retry
+      end
+
+      return result
+    end
+
+    # Array of paths to all project files
+    # (might be multiple, because of workspaces)
+    def project_paths
+      return @_project_paths if @_project_paths
+      if self.workspace?
+        # Find the xcodeproj file, as the information isn't included in the workspace file
+        # We have a reference to the workspace, let's find the xcodeproj file
+        # Use Xcodeproj gem here to
+        # * parse the contents.xcworkspacedata XML file
+        # * handle different types (group:, container: etc.) of file references and their paths
+        # for details see https://github.com/CocoaPods/Xcodeproj/blob/e0287156d426ba588c9234bb2a4c824149889860/lib/xcodeproj/workspace/file_reference.rb```
+
+        workspace_dir_path = File.expand_path("..", self.path)
+        file_references_paths = workspace.file_references.map { |fr| fr.absolute_path(workspace_dir_path) }
+        @_project_paths = file_references_paths.select do |current_match|
+          # Xcode workspaces can contain loose files now, so let's filter non-xcodeproj files.
+          current_match.end_with?(".xcodeproj")
+        end.reject do |current_match|
+          # We're not interested in a `Pods` project, as it doesn't contain any relevant information about code signing
+          current_match.end_with?("Pods/Pods.xcodeproj")
+        end
+
+        return @_project_paths
+      else
+        # Return the path as an array
+        return @_project_paths = [path]
+      end
+    end
+
+    private
+
+    # If scheme not specified, do we want the scheme
+    # matching project name?
+    def automated_scheme_selection?
+      FastlaneCore::Env.truthy?("AUTOMATED_SCHEME_SELECTION")
+    end
+  end
+end