fastlane_pricing_fix 2.212.1

data/fastlane_core/lib/fastlane_core/keychain_importer.rb

@@ -0,0 +1,128 @@
+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)
+
+      password_part = " -P #{certificate_password.shellescape}"
+
+      command = "security import #{path.shellescape} -k '#{keychain_path.shellescape}'"
+      command << password_part
+      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 << " -T /usr/bin/productsign"  # to not be asked for permission when using an installer cert for macOS
+      command << " 1> /dev/null" unless output
+
+      sensitive_command = command.gsub(password_part, " -P ********")
+      UI.command(sensitive_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
+        password_part = " -k #{keychain_password.to_s.shellescape}"
+
+        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 << password_part
+        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)")
+
+        # Strip keychain password from command output
+        sensitive_command = command.gsub(password_part, " -k ********")
+        UI.command(sensitive_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,56 @@
+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 platform from the given pkg file.
+    def self.fetch_app_platform(path)
+      return "osx"
+    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