fastlane_pricing_fix 2.212.1

data/fastlane_core/lib/fastlane_core/build_watcher.rb

@@ -0,0 +1,192 @@
+require 'spaceship/connect_api'
+
+require_relative 'ui/ui'
+
+module FastlaneCore
+  class BuildWatcherError < StandardError
+  end
+
+  class BuildWatcher
+    VersionMatches = Struct.new(:version, :builds)
+
+    class << self
+      # @return The build we waited for. This method will always return a build
+      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, timeout_duration: nil, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: false, wait_for_build_beta_detail_processing: false)
+        # Warn about train_version being removed in the future
+        if train_version
+          UI.deprecated(":train_version is no longer a used argument on FastlaneCore::BuildWatcher. Please use :app_version instead.")
+          app_version = train_version
+        end
+
+        # Warn about strict_build_watch being removed in the future
+        if strict_build_watch
+          UI.deprecated(":strict_build_watch is no longer a used argument on FastlaneCore::BuildWatcher.")
+        end
+
+        platform = Spaceship::ConnectAPI::Platform.map(platform) if platform
+        UI.message("Waiting for processing on... app_id: #{app_id}, app_version: #{app_version}, build_version: #{build_version}, platform: #{platform}")
+
+        build_watching_start_time = Time.new
+        unless timeout_duration.nil?
+          end_time = build_watching_start_time + timeout_duration
+          UI.message("Will timeout watching build after #{timeout_duration} seconds around #{end_time}...")
+        end
+
+        showed_info = false
+        loop do
+          matched_build, app_version_queried = matching_build(watched_app_version: app_version, watched_build_version: build_version, app_id: app_id, platform: platform, select_latest: select_latest)
+
+          if matched_build.nil? && !showed_info
+            UI.important("Read more information on why this build isn't showing up yet - https://github.com/fastlane/fastlane/issues/14997")
+            showed_info = true
+          end
+
+          report_status(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
+
+          # Processing of builds by AppStoreConnect can be a very time consuming task and will
+          # block the worker running this task until it is completed. In some cases,
+          # having a build resource appear in AppStoreConnect (matched_build) may be enough (i.e. setting a changelog)
+          # so here we may choose to skip the full processing of the build if return_when_build_appears is true
+          if matched_build && (return_when_build_appears || processed?(build: matched_build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing))
+
+            if !app_version.nil? && app_version != app_version_queried
+              UI.important("App version is #{app_version} but build was found while querying #{app_version_queried}")
+              UI.important("This shouldn't be an issue as Apple sees #{app_version} and #{app_version_queried} as equal")
+              UI.important("See docs for more info - https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364")
+            end
+
+            if return_spaceship_testflight_build
+              return matched_build.to_testflight_build
+            else
+              return matched_build
+            end
+          end
+
+          # Before next poll, force stop build watching, if we exceeded the 'timeout_duration' waiting time
+          force_stop_build_watching_if_required(start_time: build_watching_start_time, timeout_duration: timeout_duration)
+
+          sleep(poll_interval)
+        end
+      end
+
+      private
+
+      # Remove leading zeros ( https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364 )
+      def remove_version_leading_zeros(version: nil)
+        return version.instance_of?(String) ? version.split('.').map { |s| s.to_i.to_s }.join('.') : version
+      end
+
+      def matching_build(watched_app_version: nil, watched_build_version: nil, app_id: nil, platform: nil, select_latest: false)
+        # Get build deliveries (newly uploaded processing builds)
+        watched_app_version = remove_version_leading_zeros(version: watched_app_version)
+        watched_build_version = remove_version_leading_zeros(version: watched_build_version)
+
+        # App Store Connect will allow users to upload  X.Y is the same as X.Y.0 and treat them as the same version
+        # However, only the first uploaded version format will be the one that is queryable
+        # This could lead to BuildWatcher never finding X.Y.0 if X.Y was upoaded first as X.Y will only yield results
+        #
+        # This will add an additional request to search for both X.Y and X.Y.0 but
+        # will give preference to the version format specified passed in
+        watched_app_version_alternate = alternate_version(watched_app_version)
+        versions = [watched_app_version, watched_app_version_alternate].compact
+
+        if versions.empty?
+          if select_latest
+            message = watched_build_version.nil? ? "Searching for the latest build" : "Searching for the latest build with build number: #{watched_build_version}"
+            UI.message(message)
+            versions = [nil]
+          else
+            raise BuildWatcherError.new, "There is no app version to watch"
+          end
+        end
+
+        version_matches = versions.map do |version|
+          match = VersionMatches.new
+          match.version = version
+          match.builds = Spaceship::ConnectAPI::Build.all(
+            app_id: app_id,
+            version: version,
+            build_number: watched_build_version,
+            platform: platform
+          )
+
+          match
+        end.flatten
+
+        # Raise error if more than 1 build is returned
+        # This should never happen but need to inform the user if it does
+        matched_builds = version_matches.map(&:builds).flatten
+        if matched_builds.size > 1 && !select_latest
+          error_builds = matched_builds.map do |build|
+            "#{build.app_version}(#{build.version}) for #{build.platform} - #{build.processing_state}"
+          end.join("\n")
+          error_message = "Found more than 1 matching build: \n#{error_builds}"
+          raise BuildWatcherError.new, error_message
+        end
+
+        version_match = version_matches.reject do |match|
+          match.builds.empty?
+        end.first
+        matched_build = version_match&.builds&.first
+
+        return matched_build, version_match&.version
+      end
+
+      def alternate_version(version)
+        return nil if version.nil?
+
+        version_info = Gem::Version.new(version)
+        if version_info.segments.size == 3 && version_info.segments[2] == 0
+          return version_info.segments[0..1].join(".")
+        elsif version_info.segments.size == 2
+          return "#{version}.0"
+        end
+
+        return nil
+      end
+
+      def processed?(build: nil, wait_for_build_beta_detail_processing: false)
+        return false unless build
+
+        is_processed = build.processed?
+
+        # App Store Connect API has multiple build processing states
+        # builds have one processing status
+        # buildBetaDetails have two processing statues (internal and external testing)
+        #
+        # If set, this method will only return true if all three statuses are complete
+        if wait_for_build_beta_detail_processing
+          is_processed &&= (build.build_beta_detail&.processed? || false)
+        end
+
+        return is_processed
+      end
+
+      def report_status(build: nil, wait_for_build_beta_detail_processing: false)
+        is_processed = processed?(build: build, wait_for_build_beta_detail_processing: wait_for_build_beta_detail_processing)
+
+        if build && !is_processed
+          UI.message("Waiting for App Store Connect to finish processing the new build (#{build.app_version} - #{build.version}) for #{build.platform}")
+        elsif build && is_processed
+          UI.success("Successfully finished processing the build #{build.app_version} - #{build.version} for #{build.platform}")
+        else
+          UI.message("Waiting for the build to show up in the build list - this may take a few minutes (check your email for processing issues if this continues)")
+        end
+      end
+
+      def force_stop_build_watching_if_required(start_time: nil, timeout_duration: nil)
+        return if start_time.nil? || timeout_duration.nil? # keep watching build for App Store Connect processing
+
+        current_time = Time.new
+        end_time = start_time + timeout_duration
+        pending_duration = end_time - current_time
+
+        if current_time > end_time
+          UI.crash!("FastlaneCore::BuildWatcher exceeded the '#{timeout_duration.to_i}' seconds, Stopping now!")
+        else
+          UI.verbose("Will timeout watching build after pending #{pending_duration.to_i} seconds around #{end_time}...")
+        end
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/cert_checker.rb

@@ -0,0 +1,211 @@
+require 'tempfile'
+require 'openssl'
+
+require_relative 'features'
+require_relative 'helper'
+
+# WWDR Intermediate Certificates in https://www.apple.com/certificateauthority/
+WWDRCA_CERTIFICATES = [
+  {
+    alias: 'G1',
+    sha256: 'ce057691d730f89ca25e916f7335f4c8a15713dcd273a658c024023f8eb809c2',
+    url: 'https://developer.apple.com/certificationauthority/AppleWWDRCA.cer'
+  },
+  {
+    alias: 'G2',
+    sha256: '9ed4b3b88c6a339cf1387895bda9ca6ea31a6b5ce9edf7511845923b0c8ac94c',
+    url: 'https://www.apple.com/certificateauthority/AppleWWDRCAG2.cer'
+  },
+  {
+    alias: 'G3',
+    sha256: 'dcf21878c77f4198e4b4614f03d696d89c66c66008d4244e1b99161aac91601f',
+    url: 'https://www.apple.com/certificateauthority/AppleWWDRCAG3.cer'
+  },
+  {
+    alias: 'G4',
+    sha256: 'ea4757885538dd8cb59ff4556f676087d83c85e70902c122e42c0808b5bce14c',
+    url: 'https://www.apple.com/certificateauthority/AppleWWDRCAG4.cer'
+  },
+  {
+    alias: 'G5',
+    sha256: '53fd008278e5a595fe1e908ae9c5e5675f26243264a5a6438c023e3ce2870760',
+    url: 'https://www.apple.com/certificateauthority/AppleWWDRCAG5.cer'
+  },
+  {
+    alias: 'G6',
+    sha256: 'bdd4ed6e74691f0c2bfd01be0296197af1379e0418e2d300efa9c3bef642ca30',
+    url: 'https://www.apple.com/certificateauthority/AppleWWDRCAG6.cer'
+  }
+]
+
+module FastlaneCore
+  # This class checks if a specific certificate is installed on the current mac
+  class CertChecker
+    def self.installed?(path, in_keychain: nil)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      ids = installed_identies(in_keychain: in_keychain)
+      ids += installed_installers(in_keychain: in_keychain)
+      finger_print = sha1_fingerprint(path)
+
+      return ids.include?(finger_print)
+    end
+
+    # Legacy Method, use `installed?` instead
+    def self.is_installed?(path)
+      installed?(path)
+    end
+
+    def self.installed_identies(in_keychain: nil)
+      install_missing_wwdr_certificates
+
+      available = list_available_identities(in_keychain: in_keychain)
+      # Match for this text against word boundaries to avoid edge cases around multiples of 10 identities!
+      if /\b0 valid identities found\b/ =~ available
+        UI.error([
+          "There are no local code signing identities found.",
+          "You can run" << " `security find-identity -v -p codesigning #{in_keychain}".rstrip << "` to get this output.",
+          "This Stack Overflow thread has more information: https://stackoverflow.com/q/35390072/774.",
+          "(Check in Keychain Access for an expired WWDR certificate: https://stackoverflow.com/a/35409835/774 has more info.)"
+        ].join("\n"))
+      end
+
+      ids = []
+      available.split("\n").each do |current|
+        next if current.include?("REVOKED")
+        begin
+          (ids << current.match(/.*\) ([[:xdigit:]]*) \".*/)[1])
+        rescue
+          # the last line does not match
+        end
+      end
+
+      return ids
+    end
+
+    def self.installed_installers(in_keychain: nil)
+      available = self.list_available_third_party_mac_installer(in_keychain: in_keychain)
+      available += self.list_available_developer_id_installer(in_keychain: in_keychain)
+
+      return available.scan(/^SHA-1 hash: ([[:xdigit:]]+)$/).flatten
+    end
+
+    def self.list_available_identities(in_keychain: nil)
+      # -v  Show valid identities only (default is to show all identities)
+      # -p  Specify policy to evaluate
+      commands = ['security find-identity -v -p codesigning']
+      commands << in_keychain if in_keychain
+      `#{commands.join(' ')}`
+    end
+
+    def self.list_available_third_party_mac_installer(in_keychain: nil)
+      # -Z  Print SHA-256 (and SHA-1) hash of the certificate
+      # -a  Find all matching certificates, not just the first one
+      # -c  Match on "name" when searching (optional)
+      commands = ['security find-certificate -Z -a -c "3rd Party Mac Developer Installer"']
+      commands << in_keychain if in_keychain
+      `#{commands.join(' ')}`
+    end
+
+    def self.list_available_developer_id_installer(in_keychain: nil)
+      # -Z  Print SHA-256 (and SHA-1) hash of the certificate
+      # -a  Find all matching certificates, not just the first one
+      # -c  Match on "name" when searching (optional)
+      commands = ['security find-certificate -Z -a -c "Developer ID Installer"']
+      commands << in_keychain if in_keychain
+      `#{commands.join(' ')}`
+    end
+
+    def self.installed_wwdr_certificates
+      certificate_name = "Apple Worldwide Developer Relations"
+
+      # Find all installed WWDRCA certificates
+      installed_certs = []
+      Helper.backticks("security find-certificate -a -c '#{certificate_name}' -p #{wwdr_keychain.shellescape}")
+            .lines
+            .each do |line|
+        if line.start_with?('-----BEGIN CERTIFICATE-----')
+          installed_certs << line
+        else
+          installed_certs.last << line
+        end
+      end
+
+      # Get the alias (see `WWDRCA_CERTIFICATES`) of the installed WWDRCA certificates
+      installed_certs
+        .map do |pem|
+          sha256 = Digest::SHA256.hexdigest(OpenSSL::X509::Certificate.new(pem).to_der)
+          WWDRCA_CERTIFICATES.find { |c| c[:sha256].casecmp?(sha256) }&.fetch(:alias)
+        end
+        .compact
+    end
+
+    def self.install_missing_wwdr_certificates
+      # Install all Worldwide Developer Relations Intermediate Certificates listed here: https://www.apple.com/certificateauthority/
+      missing = WWDRCA_CERTIFICATES.map { |c| c[:alias] } - installed_wwdr_certificates
+      missing.each do |cert_alias|
+        install_wwdr_certificate(cert_alias)
+      end
+      missing.count
+    end
+
+    def self.install_wwdr_certificate(cert_alias)
+      url = WWDRCA_CERTIFICATES.find { |c| c[:alias] == cert_alias }.fetch(:url)
+      file = Tempfile.new(File.basename(url))
+      filename = file.path
+      keychain = wwdr_keychain
+      keychain = "-k #{keychain.shellescape}" unless keychain.empty?
+
+      # Attempts to fix an issue installing WWDR cert tends to fail on CIs
+      # https://github.com/fastlane/fastlane/issues/20960
+      curl_extras = ""
+      if FastlaneCore::Feature.enabled?('FASTLANE_WWDR_USE_HTTP1_AND_RETRIES')
+        curl_extras = "--http1.1 --retry 3 --retry-all-errors "
+      end
+
+      import_command = "curl #{curl_extras}-f -o #{filename} #{url} && security import #{filename} #{keychain}"
+      UI.verbose("Installing WWDR Cert: #{import_command}")
+
+      require 'open3'
+      stdout, stderr, status = Open3.capture3(import_command)
+      if FastlaneCore::Globals.verbose?
+        UI.command_output(stdout)
+        UI.command_output(stderr)
+      end
+
+      unless status.success?
+        UI.verbose("Failed to install WWDR Certificate, checking output to see why")
+        # Check the command output, WWDR might already exist
+        unless /The specified item already exists in the keychain./ =~ stderr
+          UI.user_error!("Could not install WWDR certificate")
+        end
+        UI.verbose("WWDR Certificate was already installed")
+      end
+      return true
+    end
+
+    def self.wwdr_keychain
+      priority = [
+        "security default-keychain -d user",
+        "security list-keychains -d user"
+      ]
+      priority.each do |command|
+        keychains = Helper.backticks(command, print: FastlaneCore::Globals.verbose?).split("\n")
+        unless keychains.empty?
+          # Select first keychain name from returned keychains list
+          return keychains[0].strip.tr('"', '')
+        end
+      end
+      return ""
+    end
+
+    def self.sha1_fingerprint(path)
+      file_data = File.read(path.to_s)
+      cert = OpenSSL::X509::Certificate.new(file_data)
+      return OpenSSL::Digest::SHA1.new(cert.to_der).to_s.upcase
+    rescue => error
+      UI.error(error)
+      UI.user_error!("Error parsing certificate '#{path}'")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/clipboard.rb

@@ -0,0 +1,20 @@
+require 'fastlane_core'
+require 'open3'
+
+module FastlaneCore
+  class Clipboard
+    def self.copy(content: nil)
+      return UI.crash!("'pbcopy' or 'pbpaste' command not found.") unless is_supported?
+      Open3.popen3('pbcopy') { |input, _, _| input << content }
+    end
+
+    def self.paste
+      return UI.crash!("'pbcopy' or 'pbpaste' command not found.") unless is_supported?
+      return `pbpaste`
+    end
+
+    def self.is_supported?
+      return `which pbcopy`.length > 0 && `which pbpaste`.length > 0
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/command_executor.rb

@@ -0,0 +1,94 @@
+require_relative 'ui/ui'
+require_relative 'globals'
+require_relative 'fastlane_pty'
+
+module FastlaneCore
+  # Executes commands and takes care of error handling and more
+  class CommandExecutor
+    class << self
+      # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+      # valid file extensions for executables on Windows.
+      #
+      #    which('ruby') #=> /usr/bin/ruby
+      #
+      # Derived from https://stackoverflow.com/a/5471032/3005
+      def which(cmd)
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          cmd_path = File.join(path, cmd)
+          executable_path = Helper.get_executable_path(cmd_path)
+          return executable_path if Helper.executable?(executable_path)
+        end
+
+        return nil
+      end
+
+      # @param command [String] The command to be executed
+      # @param print_all [Boolean] Do we want to print out the command output while running?
+      # @param print_command [Boolean] Should we print the command that's being executed
+      # @param error [Block] A block that's called if an error occurs
+      # @param prefix [Array] An array containing a prefix + block which might get applied to the output
+      # @param loading [String] A loading string that is shown before the first output
+      # @param suppress_output [Boolean] Should we print the command's output?
+      # @return [String] All the output as string
+      def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil, suppress_output: false)
+        print_all = true if FastlaneCore::Globals.verbose?
+        prefix ||= {}
+
+        output = []
+        command = command.join(" ") if command.kind_of?(Array)
+        UI.command(command) if print_command
+
+        if print_all && loading # this is only used to show the "Loading text"...
+          UI.command_output(loading)
+        end
+
+        begin
+          status = FastlaneCore::FastlanePty.spawn(command) do |command_stdout, command_stdin, pid|
+            command_stdout.each do |l|
+              line = l.chomp
+              line = line[1..-1] if line[0] == "\r"
+              output << line
+
+              next unless print_all
+
+              # Prefix the current line with a string
+              prefix.each do |element|
+                line = element[:prefix] + line if element[:block] && element[:block].call(line)
+              end
+
+              UI.command_output(line) unless suppress_output
+            end
+          end
+        rescue => ex
+          # FastlanePty adds exit_status on to StandardError so every error will have a status code
+          status = ex.exit_status
+
+          # This could happen when the environment is wrong:
+          # > invalid byte sequence in US-ASCII (ArgumentError)
+          output << ex.to_s
+          o = output.join("\n")
+          puts(o)
+          if error
+            error.call(o, nil)
+          else
+            raise ex
+          end
+        end
+
+        # Exit status for build command, should be 0 if build succeeded
+        if status != 0
+          o = output.join("\n")
+          puts(o) unless suppress_output # the user has the right to see the raw output
+          UI.error("Exit status: #{status}")
+          if error
+            error.call(o, status)
+          else
+            UI.user_error!("Exit status: #{status}")
+          end
+        end
+
+        return output.join("\n")
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -0,0 +1,108 @@
+require 'commander'
+
+require_relative '../module'
+require_relative '../ui/ui'
+
+module FastlaneCore
+  class CommanderGenerator
+    include Commander::Methods
+
+    # Calls the appropriate methods for commander to show the available parameters
+    def generate(options, command: nil)
+      # First, enable `always_trace`, to show the stack trace
+      always_trace!
+
+      used_switches = []
+      options.each do |option|
+        next if option.description.to_s.empty? # "private" options
+        next unless option.display_in_shell
+
+        short_switch = option.short_option
+        key = option.key
+        validate_short_switch(used_switches, short_switch, key)
+
+        type = option.data_type
+
+        # We added type: Hash to code generation, but Ruby's OptionParser doesn't like that
+        # so we need to switch that to something that is supported, luckily, we have an `is_string`
+        # property and if that is false, we'll default to nil
+        if type == Hash
+          type = option.is_string ? String : nil
+        end
+
+        # OptionParser doesn't like symbol but a symbol and string can be easily cast with `to_sym` and `to_s`
+        if type == Symbol
+          type = String
+        end
+
+        # Boolean is a fastlane thing, it's either TrueClass, or FalseClass, but we won't know
+        # that until runtime, so nil is the best we get
+        if type == Fastlane::Boolean
+          type = nil
+        end
+
+        # This is an important bit of trickery to solve the boolean option situation.
+        #
+        # Typically, boolean command line flags do not accept trailing values. If the flag
+        # is present, the value is true, if it is missing, the value is false. fastlane
+        # supports this style of flag. For example, you can specify a flag like `--clean`,
+        # and the :clean option will be true.
+        #
+        # However, fastlane also supports another boolean flag style that accepts trailing
+        # values much like options for Strings and other value types. That looks like
+        # `--include_bitcode false` The problem is that this does not work out of the box
+        # for Commander and OptionsParser. So, we need to get tricky.
+        #
+        # The value_appendix below acts as a placeholder in the switch definition that
+        # states that we expect to have a trailing value for our options. When an option
+        # declares a data type, we use the name of that data type in all caps like:
+        # "--devices ARRAY". When the data type is nil, this implies that we're going
+        # to be doing some special handling on that value. One special thing we do
+        # automatically in Configuration is to coerce special Strings into boolean values.
+        #
+        # If the data type is nil, the trick we do is to specify a value placeholder, but
+        # we wrap it in [] brackets to mark it as optional. That means that the trailing
+        # value may or may not be present for this flag. If the flag is present, but the
+        # value is not, we get a value of `true`. Perfect for the boolean flag base-case!
+        # If the value is there, we'll actually get it back as a String, which we can
+        # later coerce into a boolean.
+        #
+        # In this way we support handling boolean flags with or without trailing values.
+        value_appendix = (type || '[VALUE]').to_s.upcase
+        long_switch = "--#{option.key} #{value_appendix}"
+
+        description = option.description
+        description += " (#{option.env_names.join(', ')})" unless option.env_names.empty?
+
+        # We compact this array here to remove the short_switch variable if it is nil.
+        # Passing a nil value to global_option has been shown to create problems with
+        # option parsing!
+        #
+        # See: https://github.com/fastlane/fastlane_core/pull/89
+        #
+        # If we don't have a data type for this option, we tell it to act like a String.
+        # This allows us to get a reasonable value for boolean options that can be
+        # automatically coerced or otherwise handled by the ConfigItem for others.
+        args = [short_switch, long_switch, (type || String), description].compact
+
+        if command
+          command.option(*args)
+        else
+          # This is the call to Commander to set up the option we've been building.
+          global_option(*args)
+        end
+      end
+    end
+
+    def validate_short_switch(used_switches, short_switch, key)
+      return if short_switch.nil?
+
+      UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
+      UI.user_error!("-v is already used for the fastlane version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the fastlane help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the fastlane trace screen (key #{key})") if short_switch == "-t"
+
+      used_switches << short_switch
+    end
+  end
+end