fastlane_hotfix 2.165.0

data/fastlane_core/lib/fastlane_core/analytics/analytics_event_builder.rb

@@ -0,0 +1,23 @@
+module FastlaneCore
+  class AnalyticsEventBuilder
+    attr_accessor :action_name
+
+    # fastlane_client_language valid options are :ruby or :swift
+    def initialize(p_hash: nil, session_id: nil, action_name: nil, fastlane_client_language: :ruby)
+      @p_hash = p_hash
+      @session_id = session_id
+      @action_name = action_name
+      @fastlane_client_language = fastlane_client_language
+    end
+
+    def new_event(action_stage)
+      {
+        client_id: @p_hash,
+        category: "fastlane Client Language - #{@fastlane_client_language}",
+        action: action_stage,
+        label: action_name,
+        value: nil
+      }
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/analytics_ingester_client.rb

@@ -0,0 +1,54 @@
+require 'faraday'
+require 'openssl'
+require 'json'
+
+require_relative '../helper'
+
+module FastlaneCore
+  class AnalyticsIngesterClient
+    GA_URL = "https://www.google-analytics.com"
+
+    private_constant :GA_URL
+
+    def initialize(ga_tracking)
+      @ga_tracking = ga_tracking
+    end
+
+    def post_event(event)
+      # If our users want to opt out of usage metrics, don't post the events.
+      # Learn more at https://docs.fastlane.tools/#metrics
+      if Helper.test? || FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
+        return nil
+      end
+      return Thread.new do
+        send_request(event)
+      end
+    end
+
+    def send_request(event, retries: 2)
+      post_request(event)
+    rescue
+      retries -= 1
+      retry if retries >= 0
+    end
+
+    def post_request(event)
+      connection = Faraday.new(GA_URL) do |conn|
+        conn.request(:url_encoded)
+        conn.adapter(Faraday.default_adapter)
+      end
+      connection.headers[:user_agent] = 'fastlane/' + Fastlane::VERSION
+      connection.post("/collect", {
+        v: "1",                                            # API Version
+        tid: @ga_tracking,                                 # Tracking ID / Property ID
+        cid: event[:client_id],                            # Client ID
+        t: "event",                                        # Event hit type
+        ec: event[:category],                              # Event category
+        ea: event[:action],                                # Event action
+        el: event[:label] || "na",                         # Event label
+        ev: event[:value] || "0",                          # Event value
+        aip: "1"                                           # IP anonymization
+      })
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/analytics_session.rb

@@ -0,0 +1,70 @@
+require_relative 'analytics_ingester_client'
+require_relative 'action_launch_context'
+require_relative 'analytics_event_builder'
+
+module FastlaneCore
+  class AnalyticsSession
+    GA_TRACKING = "UA-121171860-1"
+
+    private_constant :GA_TRACKING
+    attr_accessor :session_id
+    attr_accessor :client
+
+    def initialize(analytics_ingester_client: AnalyticsIngesterClient.new(GA_TRACKING))
+      require 'securerandom'
+      @session_id = SecureRandom.uuid
+      @client = analytics_ingester_client
+      @threads = []
+      @launch_event_sent = false
+    end
+
+    def action_launched(launch_context: nil)
+      if should_show_message?
+        show_message
+      end
+
+      if @launch_event_sent || launch_context.p_hash.nil?
+        return
+      end
+
+      @launch_event_sent = true
+      builder = AnalyticsEventBuilder.new(
+        p_hash: launch_context.p_hash,
+        session_id: session_id,
+        action_name: nil,
+        fastlane_client_language: launch_context.fastlane_client_language
+      )
+
+      launch_event = builder.new_event(:launch)
+      post_thread = client.post_event(launch_event)
+      unless post_thread.nil?
+        @threads << post_thread
+      end
+    end
+
+    def action_completed(completion_context: nil)
+    end
+
+    def show_message
+      UI.message("Sending anonymous analytics information")
+      UI.message("Learn more at https://docs.fastlane.tools/#metrics")
+      UI.message("No personal or sensitive data is sent.")
+      UI.message("You can disable this by adding `opt_out_usage` at the top of your Fastfile")
+    end
+
+    def should_show_message?
+      return false if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
+
+      file_name = ".did_show_opt_info"
+      new_path = File.join(FastlaneCore.fastlane_user_dir, file_name)
+      return false if File.exist?(new_path)
+
+      File.write(new_path, '1')
+      true
+    end
+
+    def finalize_session
+      @threads.map(&:join)
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/analytics/app_identifier_guesser.rb

@@ -0,0 +1,64 @@
+require_relative '../android_package_name_guesser'
+require_relative '../ios_app_identifier_guesser'
+require_relative '../env'
+
+module FastlaneCore
+  class AppIdentifierGuesser
+    attr_accessor :args
+    attr_accessor :gem_name
+    attr_accessor :platform
+    attr_accessor :p_hash
+    attr_accessor :app_id
+
+    def initialize(args: nil, gem_name: 'fastlane')
+      @args = args
+      @gem_name = gem_name
+
+      @app_id = android_app_identifier(args, gem_name)
+      @platform = nil # since have a state in-between runs
+      if @app_id
+        @platform = :android
+      else
+        @app_id = ios_app_identifier(args)
+        @platform = :ios if @app_id
+      end
+
+      @p_hash = generate_p_hash(@app_id)
+    end
+
+    # To not count the same projects multiple time for the number of launches
+    # Learn more at https://docs.fastlane.tools/#metrics
+    # Use the `FASTLANE_OPT_OUT_USAGE` variable to opt out
+    # The resulting value is e.g. ce12f8371df11ef6097a83bdf2303e4357d6f5040acc4f76019489fa5deeae0d
+    def generate_p_hash(app_id)
+      if app_id.nil?
+        return nil
+      end
+
+      return Digest::SHA256.hexdigest("p#{app_id}fastlan3_SAlt") # hashed + salted the bundle identifier
+    rescue
+      return nil # we don't want this method to cause a crash
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    def ios_app_identifier(args)
+      return FastlaneCore::IOSAppIdentifierGuesser.guess_app_identifier(args)
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    # supply and screengrab use different param names and env variable patterns so we have to special case here
+    # example:
+    #   fastlane supply --skip_upload_screenshots -a beta -p com.test.app should return com.test.app
+    #   screengrab -a com.test.app should return com.test.app
+    def android_app_identifier(args, gem_name)
+      app_identifier = FastlaneCore::AndroidPackageNameGuesser.guess_package_name(gem_name, args)
+
+      # Add Android prefix to prevent collisions if there is an iOS app with the same identifier
+      app_identifier ? "android_project_#{app_identifier}" : nil
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/android_package_name_guesser.rb

@@ -0,0 +1,79 @@
+require 'credentials_manager/appfile_config'
+
+require_relative 'configuration/configuration'
+require_relative 'env'
+
+module FastlaneCore
+  class AndroidPackageNameGuesser
+    class << self
+      def android_package_name_arg?(gem_name, arg)
+        return arg == "--package_name" ||
+               arg == "--app_package_name" ||
+               (arg == '-p' && gem_name == 'supply') ||
+               (arg == '-a' && gem_name == 'screengrab')
+      end
+
+      def guess_package_name_from_args(gem_name, args)
+        # args example: ["-a", "com.krausefx.app"]
+        package_name = nil
+        args.each_with_index do |current, index|
+          next unless android_package_name_arg?(gem_name, current)
+          # argument names are followed by argument values in the args array;
+          # use [index + 1] to find the package name (range check the array
+          # to avoid array bounds errors)
+          package_name = args[index + 1] if args.count > index
+          break
+        end
+        package_name
+      end
+
+      def guess_package_name_from_environment
+        package_name = nil
+        package_name ||= ENV["SUPPLY_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SUPPLY_PACKAGE_NAME")
+        package_name ||= ENV["SCREENGRAB_APP_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SCREENGRAB_APP_PACKAGE_NAME")
+        package_name
+      end
+
+      def guess_package_name_from_appfile
+        CredentialsManager::AppfileConfig.try_fetch_value(:package_name)
+      end
+
+      def fetch_package_name_from_file(file_name, package_name_key)
+        # we only care about the package name item in the configuration file, so
+        # build an options array & Configuration with just that one key and it will
+        # be fetched if it is present in the config file
+        genericfile_options = [FastlaneCore::ConfigItem.new(key: package_name_key)]
+        options = FastlaneCore::Configuration.create(genericfile_options, {})
+        # pass the empty proc to disable options validation, otherwise this will fail
+        # when the other (non-package name) keys are encountered in the config file;
+        # 3rd parameter "true" disables the printout of the contents of the
+        # configuration file, which is noisy and confusing in this case
+        options.load_configuration_file(file_name, proc {}, true)
+        return options.fetch(package_name_key, ask: false)
+      rescue
+        # any option/file error here should just be treated as identifier not found
+        nil
+      end
+
+      def guess_package_name_from_config_files
+        package_name = nil
+        package_name ||= fetch_package_name_from_file("Supplyfile", :package_name)
+        package_name ||= fetch_package_name_from_file("Screengrabfile", :app_package_name)
+        package_name
+      end
+
+      # make a best-guess for the package_name for this project, using most-reliable signals
+      #  first and then using less accurate ones afterwards; because this method only returns
+      #  a GUESS for the package_name, it is only useful for metrics or other places where
+      #  absolute accuracy is not required
+      def guess_package_name(gem_name, args)
+        package_name = nil
+        package_name ||= guess_package_name_from_args(gem_name, args)
+        package_name ||= guess_package_name_from_environment
+        package_name ||= guess_package_name_from_appfile
+        package_name ||= guess_package_name_from_config_files
+        package_name
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/build_watcher.rb

@@ -0,0 +1,96 @@
+require 'spaceship/connect_api'
+
+require_relative 'ui/ui'
+
+module FastlaneCore
+  class BuildWatcher
+    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, strict_build_watch: false, return_when_build_appears: false, return_spaceship_testflight_build: true, select_latest: 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}")
+
+        showed_info = false
+        loop do
+          matched_build = 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)
+
+          # 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 || matched_build.processed?)
+            if return_spaceship_testflight_build
+              return matched_build.to_testflight_build
+            else
+              return matched_build
+            end
+          end
+
+          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)
+
+        matched_builds = Spaceship::ConnectAPI::Build.all(
+          app_id: app_id,
+          version: watched_app_version,
+          build_number: watched_build_version,
+          platform: platform
+        )
+
+        # Raise error if more than 1 build is returned
+        # This should never happen but need to inform the user if it does
+        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 = "FastlaneCore::BuildWatcher found more than 1 matching build: \n#{error_builds}"
+          UI.crash!(error_message)
+        end
+
+        matched_build = matched_builds.first
+
+        return matched_build
+      end
+
+      def report_status(build: nil)
+        if build && !build.processed?
+          UI.message("Waiting for App Store Connect to finish processing the new build (#{build.app_version} - #{build.version}) for #{build.platform}")
+        elsif build && build.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
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/cert_checker.rb

@@ -0,0 +1,144 @@
+require 'tempfile'
+require 'openssl'
+
+require_relative 'helper'
+
+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_wwdr_certificate unless wwdr_certificate_installed?
+
+      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.wwdr_certificate_installed?
+      certificate_name = "Apple Worldwide Developer Relations Certification Authority"
+      keychain = wwdr_keychain
+      response = Helper.backticks("security find-certificate -c '#{certificate_name}' #{keychain.shellescape}", print: FastlaneCore::Globals.verbose?)
+      return response.include?("attributes:")
+    end
+
+    def self.install_wwdr_certificate
+      url = 'https://developer.apple.com/certificationauthority/AppleWWDRCA.cer'
+      file = Tempfile.new('AppleWWDRCA')
+      filename = file.path
+      keychain = wwdr_keychain
+      keychain = "-k #{keychain.shellescape}" unless keychain.empty?
+
+      require 'open3'
+
+      import_command = "curl -f -o #{filename} #{url} && security import #{filename} #{keychain}"
+      UI.verbose("Installing WWDR Cert: #{import_command}")
+
+      stdout, stderr, _status = Open3.capture3(import_command)
+      if FastlaneCore::Globals.verbose?
+        UI.command_output(stdout)
+        UI.command_output(stderr)
+      end
+
+      unless $?.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 list-keychains -d user",
+        "security default-keychain -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