fastlane_hotfix 2.165.0

data/gym/lib/gym/manager.rb

@@ -0,0 +1,22 @@
+require 'fastlane_core/print_table'
+require_relative 'module'
+require_relative 'runner'
+
+module Gym
+  class Manager
+    def work(options)
+      Gym.config = options
+
+      # Also print out the path to the used Xcode installation
+      # We go 2 folders up, to not show "Contents/Developer/"
+      values = Gym.config.values(ask: false)
+      values[:xcode_path] = File.expand_path("../..", FastlaneCore::Helper.xcode_path)
+
+      FastlaneCore::PrintTable.print_values(config: values,
+                                         hide_keys: [],
+                                             title: "Summary for gym #{Fastlane::VERSION}")
+
+      return Runner.new.run
+    end
+  end
+end

data/gym/lib/gym/module.rb

@@ -0,0 +1,74 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+require_relative 'detect_values'
+
+module Gym
+  class << self
+    attr_accessor :config
+
+    attr_accessor :project
+
+    attr_accessor :cache
+
+    def config=(value)
+      @config = value
+      DetectValues.set_additional_default_values
+      @cache = {}
+    end
+
+    def gymfile_name
+      "Gymfile"
+    end
+
+    def init_libs
+      # Import all the fixes
+      require 'gym/xcodebuild_fixes/generic_archive_fix'
+    end
+
+    def building_for_ios?
+      if Gym.project.mac?
+        # Can be building for iOS if mac project and catalyst
+        return building_mac_catalyst_for_ios?
+      else
+        # Can be iOS project and build for mac if catalyst
+        return false if building_mac_catalyst_for_mac?
+
+        # Can be iOS project if iOS, tvOS, or watchOS
+        return Gym.project.ios? || Gym.project.tvos? || Gym.project.watchos?
+      end
+    end
+
+    def building_for_mac?
+      if Gym.project.supports_mac_catalyst?
+        # Can be a mac project and not build mac if catalyst
+        return building_mac_catalyst_for_mac?
+      else
+        return Gym.project.mac?
+      end
+    end
+
+    def building_mac_catalyst_for_ios?
+      Gym.project.supports_mac_catalyst? && Gym.config[:catalyst_platform] == "ios"
+    end
+
+    def building_mac_catalyst_for_mac?
+      Gym.project.supports_mac_catalyst? && Gym.config[:catalyst_platform] == "macos"
+    end
+
+    def export_destination_upload?
+      config_path = Gym.cache[:config_path]
+      return false if config_path.nil?
+
+      result = CFPropertyList.native_types(CFPropertyList::List.new(file: config_path).value)
+      return result["destination"] == "upload"
+    end
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  Boolean = Fastlane::Boolean
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+  DESCRIPTION = "Building your iOS apps has never been easier"
+
+  Gym.init_libs
+end

data/gym/lib/gym/options.rb

@@ -0,0 +1,286 @@
+require 'fastlane_core/configuration/config_item'
+require 'credentials_manager/appfile_config'
+require_relative 'module'
+
+module Gym
+  class Options
+    def self.available_options
+      return @options if @options
+
+      @options = plain_options
+    end
+
+    def self.plain_options
+      [
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     short_option: "-w",
+                                     env_name: "GYM_WORKSPACE",
+                                     optional: true,
+                                     description: "Path to the workspace file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       UI.user_error!("Workspace file not found at path '#{v}'") unless File.exist?(v)
+                                       UI.user_error!("Workspace file invalid") unless File.directory?(v)
+                                       UI.user_error!("Workspace file is not a workspace, must end with .xcworkspace") unless v.include?(".xcworkspace")
+                                     end,
+                                     conflicting_options: [:project],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can only pass either a 'workspace' or a '#{value.key}', not both")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :project,
+                                     short_option: "-p",
+                                     optional: true,
+                                     env_name: "GYM_PROJECT",
+                                     description: "Path to the project file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       UI.user_error!("Project file not found at path '#{v}'") unless File.exist?(v)
+                                       UI.user_error!("Project file invalid") unless File.directory?(v)
+                                       UI.user_error!("Project file is not a project file, must end with .xcodeproj") unless v.include?(".xcodeproj")
+                                     end,
+                                     conflicting_options: [:workspace],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can only pass either a 'project' or a '#{value.key}', not both")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :scheme,
+                                     short_option: "-s",
+                                     optional: true,
+                                     env_name: "GYM_SCHEME",
+                                     description: "The project's scheme. Make sure it's marked as `Shared`"),
+        FastlaneCore::ConfigItem.new(key: :clean,
+                                     short_option: "-c",
+                                     env_name: "GYM_CLEAN",
+                                     description: "Should the project be cleaned before building it?",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "GYM_OUTPUT_DIRECTORY",
+                                     description: "The directory in which the ipa file should be stored in",
+                                     default_value: "."),
+        FastlaneCore::ConfigItem.new(key: :output_name,
+                                     short_option: "-n",
+                                     env_name: "GYM_OUTPUT_NAME",
+                                     description: "The name of the resulting ipa file",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :configuration,
+                                     short_option: "-q",
+                                     env_name: "GYM_CONFIGURATION",
+                                     description: "The configuration to use when building the app. Defaults to 'Release'",
+                                     default_value_dynamic: true,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :silent,
+                                     short_option: "-a",
+                                     env_name: "GYM_SILENT",
+                                     description: "Hide all information that's not necessary while building",
+                                     default_value: false,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :codesigning_identity,
+                                     short_option: "-i",
+                                     env_name: "GYM_CODE_SIGNING_IDENTITY",
+                                     description: "The name of the code signing identity to use. It has to match the name exactly. e.g. 'iPhone Distribution: SunApps GmbH'",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_package_ipa,
+                                     env_name: "GYM_SKIP_PACKAGE_IPA",
+                                     description: "Should we skip packaging the ipa?",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_package_pkg,
+                                     env_name: "GYM_SKIP_PACKAGE_PKG",
+                                     description: "Should we skip packaging the pkg?",
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :include_symbols,
+                                     short_option: "-m",
+                                     env_name: "GYM_INCLUDE_SYMBOLS",
+                                     description: "Should the ipa file include symbols?",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :include_bitcode,
+                                     short_option: "-z",
+                                     env_name: "GYM_INCLUDE_BITCODE",
+                                     description: "Should the ipa file include bitcode?",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :export_method,
+                                     short_option: "-j",
+                                     env_name: "GYM_EXPORT_METHOD",
+                                     description: "Method used to export the archive. Valid values are: app-store, ad-hoc, package, enterprise, development, developer-id",
+                                     type: String,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       av = %w(app-store ad-hoc package enterprise development developer-id)
+                                       UI.user_error!("Unsupported export_method '#{value}', must be: #{av}") unless av.include?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :export_options,
+                                     env_name: "GYM_EXPORT_OPTIONS",
+                                     description: "Path to an export options plist or a hash with export options. Use 'xcodebuild -help' to print the full set of available options",
+                                     optional: true,
+                                     type: Hash,
+                                     skip_type_validation: true,
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("'#{value.key}' must be false to use 'export_options'")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :export_xcargs,
+                                     env_name: "GYM_EXPORT_XCARGS",
+                                     description: "Pass additional arguments to xcodebuild for the package phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS=\"-ObjC -lstdc++\"",
+                                     optional: true,
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("'#{value.key}' must be false to use 'export_xcargs'")
+                                     end,
+                                     type: :shell_string),
+        FastlaneCore::ConfigItem.new(key: :skip_build_archive,
+                                     env_name: "GYM_SKIP_BUILD_ARCHIVE",
+                                     description: "Export ipa from previously built xcarchive. Uses archive_path as source",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_archive,
+                                     env_name: "GYM_SKIP_ARCHIVE",
+                                     description: "After building, don't archive, effectively not including -archivePath param",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_codesigning,
+                                     env_name: "GYM_SKIP_CODESIGNING",
+                                     description: "Build without codesigning",
+                                     type: Boolean,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :catalyst_platform,
+                                     env_name: "GYM_CATALYST_PLATFORM",
+                                     description: "Platform to build when using a Catalyst enabled app. Valid values are: ios, macos",
+                                     type: String,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       av = %w(ios macos)
+                                       UI.user_error!("Unsupported export_method '#{value}', must be: #{av}") unless av.include?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :installer_cert_name,
+                                     env_name: "GYM_INSTALLER_CERT_NAME",
+                                     description: "Full name of 3rd Party Mac Developer Installer or Developer ID Installer certificate. Example: `3rd Party Mac Developer Installer: Your Company (ABC1234XWYZ)`",
+                                     type: String,
+                                     optional: true),
+        # Very optional
+        FastlaneCore::ConfigItem.new(key: :build_path,
+                                     env_name: "GYM_BUILD_PATH",
+                                     description: "The directory in which the archive should be stored in",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :archive_path,
+                                     short_option: "-b",
+                                     env_name: "GYM_ARCHIVE_PATH",
+                                     description: "The path to the created archive",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :derived_data_path,
+                                     short_option: "-f",
+                                     env_name: "GYM_DERIVED_DATA_PATH",
+                                     description: "The directory where built products and other derived data will go",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :result_bundle,
+                                     short_option: "-u",
+                                     env_name: "GYM_RESULT_BUNDLE",
+                                     type: Boolean,
+                                     description: "Should an Xcode result bundle be generated in the output directory",
+                                     default_value: false,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :result_bundle_path,
+                                     env_name: "GYM_RESULT_BUNDLE_PATH",
+                                     description: "Path to the result bundle directory to create. Ignored if `result_bundle` if false",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :buildlog_path,
+                                     short_option: "-l",
+                                     env_name: "GYM_BUILDLOG_PATH",
+                                     description: "The directory where to store the build log",
+                                     default_value: "#{FastlaneCore::Helper.buildlog_path}/gym",
+                                     default_value_dynamic: true),
+        FastlaneCore::ConfigItem.new(key: :sdk,
+                                     short_option: "-k",
+                                     env_name: "GYM_SDK",
+                                     description: "The SDK that should be used for building the application",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :toolchain,
+                                     env_name: "GYM_TOOLCHAIN",
+                                     description: "The toolchain that should be used for building the application (e.g. com.apple.dt.toolchain.Swift_2_3, org.swift.30p620160816a)",
+                                     optional: true,
+                                     type: String),
+        FastlaneCore::ConfigItem.new(key: :destination,
+                                     short_option: "-d",
+                                     env_name: "GYM_DESTINATION",
+                                     description: "Use a custom destination for building the app",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :export_team_id,
+                                     short_option: "-g",
+                                     env_name: "GYM_EXPORT_TEAM_ID",
+                                     description: "Optional: Sometimes you need to specify a team id when exporting the ipa file",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xcargs,
+                                     short_option: "-x",
+                                     env_name: "GYM_XCARGS",
+                                     description: "Pass additional arguments to xcodebuild for the build phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS=\"-ObjC -lstdc++\"",
+                                     optional: true,
+                                     type: :shell_string),
+        FastlaneCore::ConfigItem.new(key: :xcconfig,
+                                     short_option: "-y",
+                                     env_name: "GYM_XCCONFIG",
+                                     description: "Use an extra XCCONFIG file to build your app",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("File not found at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :suppress_xcode_output,
+                                     short_option: "-r",
+                                     env_name: "SUPPRESS_OUTPUT",
+                                     description: "Suppress the output of xcodebuild to stdout. Output is still saved in buildlog_path",
+                                     optional: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :disable_xcpretty,
+                                     env_name: "DISABLE_XCPRETTY",
+                                     description: "Disable xcpretty formatting of build output",
+                                     optional: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_test_format,
+                                     env_name: "XCPRETTY_TEST_FORMAT",
+                                     description: "Use the test (RSpec style) format for build output",
+                                     optional: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_formatter,
+                                     env_name: "XCPRETTY_FORMATTER",
+                                     description: "A custom xcpretty formatter to use",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Formatter file not found at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_report_junit,
+                                     env_name: "XCPRETTY_REPORT_JUNIT",
+                                     description: "Have xcpretty create a JUnit-style XML report at the provided path",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_report_html,
+                                     env_name: "XCPRETTY_REPORT_HTML",
+                                     description: "Have xcpretty create a simple HTML report at the provided path",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_report_json,
+                                     env_name: "XCPRETTY_REPORT_JSON",
+                                     description: "Have xcpretty create a JSON compilation database at the provided path",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :analyze_build_time,
+                                     env_name: "GYM_ANALYZE_BUILD_TIME",
+                                     description: "Analyze the project build time and store the output in 'culprits.txt' file",
+                                     optional: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_utf,
+                                     env_name: "XCPRETTY_UTF",
+                                     description: "Have xcpretty use unicode encoding when reporting builds",
+                                     optional: true,
+                                     type: Boolean),
+        FastlaneCore::ConfigItem.new(key: :skip_profile_detection,
+                                     env_name: "GYM_SKIP_PROFILE_DETECTION",
+                                     description: "Do not try to build a profile mapping from the xcodeproj. Match or a manually provided mapping should be used",
+                                     optional: true,
+                                     type: Boolean,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :cloned_source_packages_path,
+                                     env_name: "GYM_CLONED_SOURCE_PACKAGES_PATH",
+                                     description: "Sets a custom path for Swift Package Manager dependencies",
+                                     type: String,
+                                     optional: true)
+      ]
+    end
+  end
+end

data/gym/lib/gym/runner.rb

@@ -0,0 +1,365 @@
+require 'open3'
+require 'fileutils'
+require 'shellwords'
+require 'terminal-table'
+
+require 'fastlane_core/print_table'
+require 'fastlane_core/command_executor'
+require_relative 'module'
+require_relative 'generators/package_command_generator'
+require_relative 'generators/build_command_generator'
+require_relative 'error_handler'
+
+module Gym
+  class Runner
+    # @return (String) The path to the resulting ipa
+    def run
+      unless Gym.config[:skip_build_archive]
+        build_app
+      end
+      verify_archive unless Gym.config[:skip_archive]
+
+      return nil if Gym.config[:skip_archive]
+
+      FileUtils.mkdir_p(File.expand_path(Gym.config[:output_directory]))
+
+      # Archive
+      if Gym.building_for_ios?
+        fix_generic_archive unless Gym.project.watchos? # See https://github.com/fastlane/fastlane/pull/4325
+        return BuildCommandGenerator.archive_path if Gym.config[:skip_package_ipa]
+
+        package_app
+        compress_and_move_dsym
+
+        unless Gym.export_destination_upload?
+          path = move_ipa
+          move_manifest
+          move_app_thinning
+          move_app_thinning_size_report
+          move_apps_folder
+          move_asset_packs
+          move_appstore_info
+        end
+      elsif Gym.building_for_mac?
+        path = File.expand_path(Gym.config[:output_directory])
+        compress_and_move_dsym
+        if Gym.project.mac_app? || Gym.building_mac_catalyst_for_mac?
+          path = copy_mac_app
+          return path if Gym.config[:skip_package_pkg]
+
+          package_app
+          unless Gym.export_destination_upload?
+            path = move_pkg
+            move_appstore_info
+          end
+          return path
+        end
+        copy_files_from_path(File.join(BuildCommandGenerator.archive_path, "Products/usr/local/bin/*")) if Gym.project.command_line_tool?
+      end
+      return path
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    #####################################################
+    # @!group Printing out things
+    #####################################################
+
+    # @param [Array] An array containing all the parts of the command
+    def print_command(command, title)
+      rows = command.map do |c|
+        current = c.to_s.dup
+        next unless current.length > 0
+
+        match_default_parameter = current.match(/(-.*) '(.*)'/)
+        if match_default_parameter
+          # That's a default parameter, like `-project 'Name'`
+          match_default_parameter[1, 2]
+        else
+          current.gsub!("| ", "\| ") # as the | will somehow break the terminal table
+          [current, ""]
+        end
+      end
+
+      puts(Terminal::Table.new(
+             title: title.green,
+             headings: ["Option", "Value"],
+             rows: FastlaneCore::PrintTable.transform_output(rows.delete_if { |c| c.to_s.empty? })
+      ))
+    end
+
+    private
+
+    #####################################################
+    # @!group The individual steps
+    #####################################################
+
+    def fix_generic_archive
+      return unless FastlaneCore::Env.truthy?("GYM_USE_GENERIC_ARCHIVE_FIX")
+      Gym::XcodebuildFixes.generic_archive_fix
+    end
+
+    def mark_archive_as_built_by_gym(archive_path)
+      escaped_archive_path = archive_path.shellescape
+      system("xattr -w info.fastlane.generated_by_gym 1 #{escaped_archive_path}")
+    end
+
+    # Builds the app and prepares the archive
+    def build_app
+      command = BuildCommandGenerator.generate
+      print_command(command, "Generated Build Command") if FastlaneCore::Globals.verbose?
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: !Gym.config[:silent],
+                                              error: proc do |output|
+                                                ErrorHandler.handle_build_error(output)
+                                              end)
+
+      unless Gym.config[:skip_archive]
+        mark_archive_as_built_by_gym(BuildCommandGenerator.archive_path)
+        UI.success("Successfully stored the archive. You can find it in the Xcode Organizer.") unless Gym.config[:archive_path].nil?
+        UI.verbose("Stored the archive in: " + BuildCommandGenerator.archive_path)
+      end
+
+      post_build_app
+    end
+
+    # Post-processing of build_app
+    def post_build_app
+      command = BuildCommandGenerator.post_build
+
+      return if command.empty?
+
+      print_command(command, "Generated Post-Build Command") if FastlaneCore::Globals.verbose?
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: !Gym.config[:silent],
+                                              error: proc do |output|
+                                                ErrorHandler.handle_build_error(output)
+                                              end)
+    end
+
+    # Makes sure the archive is there and valid
+    def verify_archive
+      # from https://github.com/fastlane/fastlane/issues/3179
+      if (Dir[BuildCommandGenerator.archive_path + "/*"]).count == 0
+        ErrorHandler.handle_empty_archive
+      end
+    end
+
+    def package_app
+      command = PackageCommandGenerator.generate
+      print_command(command, "Generated Package Command") if FastlaneCore::Globals.verbose?
+
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: false,
+                                      print_command: !Gym.config[:silent],
+                                              error: proc do |output|
+                                                ErrorHandler.handle_package_error(output)
+                                              end)
+    end
+
+    def compress_and_move_dsym
+      return unless PackageCommandGenerator.dsym_path
+
+      # Compress and move the dsym file
+      containing_directory = File.expand_path("..", PackageCommandGenerator.dsym_path)
+      bcsymbolmaps_directory = File.expand_path("../../BCSymbolMaps", PackageCommandGenerator.dsym_path)
+      available_dsyms = Dir.glob("#{containing_directory}/*.dSYM")
+      uuid_regex = /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/
+
+      if Dir.exist?(bcsymbolmaps_directory)
+        UI.message("Mapping dSYM(s) using generated BCSymbolMaps") unless Gym.config[:silent]
+        available_dsyms.each do |dsym|
+          dwarfdump_command = []
+          dwarfdump_command << "dwarfdump"
+          dwarfdump_command << "--uuid #{dsym.shellescape}"
+
+          # Extract uuids
+          dwarfdump_result = Helper.backticks(dwarfdump_command.join(" "), print: false)
+          architecture_infos = dwarfdump_result.split("\n")
+          architecture_infos.each do |info|
+            info_array = info.split(" ", 4)
+            uuid = info_array[1]
+            dwarf_file_path = info_array[3]
+
+            if uuid.nil? || !uuid.match(uuid_regex)
+              next
+            end
+
+            # Find bcsymbolmap file to be used:
+            #  - if a <uuid>.plist file exists, we will extract uuid of bcsymbolmap and use it
+            #  - if a <uuid>.bcsymbolmap file exists, we will use it
+            #  - otherwise let dsymutil figure it out
+            symbol_map_path = nil
+            split_dwarf_file_path = File.split(dwarf_file_path)
+            dsym_plist_file_path = File.join(split_dwarf_file_path[0], "..", "#{uuid}.plist")
+            if File.exist?(dsym_plist_file_path)
+              dsym_plist = Plist.parse_xml(dsym_plist_file_path)
+              original_uuid = dsym_plist['DBGOriginalUUID']
+              possible_symbol_map_path = "#{bcsymbolmaps_directory}/#{original_uuid}.bcsymbolmap"
+              if File.exist?(possible_symbol_map_path)
+                symbol_map_path = possible_symbol_map_path.shellescape
+              end
+            end
+            if symbol_map_path.nil?
+              possible_symbol_map_path = File.join(bcsymbolmaps_directory, "#{uuid}.bcsymbolmap")
+              if File.exist?(possible_symbol_map_path)
+                symbol_map_path = possible_symbol_map_path.shellescape
+              end
+            end
+            if symbol_map_path.nil?
+              symbol_map_path = bcsymbolmaps_directory.shellescape
+            end
+            command = []
+            command << "dsymutil"
+            command << "--symbol-map #{symbol_map_path}"
+            command << dsym.shellescape
+            Helper.backticks(command.join(" "), print: !Gym.config[:silent])
+          end
+        end
+      end
+
+      UI.message("Compressing #{available_dsyms.count} dSYM(s)") unless Gym.config[:silent]
+
+      output_path = File.expand_path(File.join(Gym.config[:output_directory], Gym.config[:output_name] + ".app.dSYM.zip"))
+      command = "cd '#{containing_directory}' && zip -r '#{output_path}' *.dSYM"
+      Helper.backticks(command, print: !Gym.config[:silent])
+      puts("") # new line
+
+      UI.success("Successfully exported and compressed dSYM file")
+    end
+
+    # Moves over the binary and dsym file to the output directory
+    # @return (String) The path to the resulting ipa file
+    def move_ipa
+      FileUtils.mv(PackageCommandGenerator.ipa_path, File.expand_path(Gym.config[:output_directory]), force: true)
+      ipa_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.ipa_path)))
+
+      UI.success("Successfully exported and signed the ipa file:")
+      UI.message(ipa_path)
+      ipa_path
+    end
+
+    # Moves over the binary and dsym file to the output directory
+    # @return (String) The path to the resulting pkg file
+    def move_pkg
+      FileUtils.mv(PackageCommandGenerator.pkg_path, File.expand_path(Gym.config[:output_directory]), force: true)
+      pkg_path = File.expand_path(File.join(Gym.config[:output_directory], File.basename(PackageCommandGenerator.pkg_path)))
+
+      UI.success("Successfully exported and signed the pkg file:")
+      UI.message(pkg_path)
+      pkg_path
+    end
+
+    # copys framework from temp folder:
+
+    def copy_files_from_path(path)
+      UI.success("Exporting Files:")
+      Dir[path].each do |f|
+        existing_file = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(f))
+        # If the target file already exists in output directory
+        # we have to remove it first, otherwise cp_r fails even with remove_destination
+        # e.g.: there are symlinks in the .framework
+        if File.exist?(existing_file)
+          UI.important("Removing #{File.basename(f)} from output directory") if FastlaneCore::Globals.verbose?
+          FileUtils.rm_rf(existing_file)
+        end
+        FileUtils.cp_r(f, File.expand_path(Gym.config[:output_directory]), remove_destination: true)
+        UI.message("\t ▸ #{File.basename(f)}")
+      end
+    end
+
+    # Copies the .app from the archive into the output directory
+    def copy_mac_app
+      exe_name = Gym.project.build_settings(key: "EXECUTABLE_NAME")
+      app_path = File.join(BuildCommandGenerator.archive_path, "Products/Applications/#{exe_name}.app")
+
+      UI.crash!("Couldn't find application in '#{BuildCommandGenerator.archive_path}'") unless File.exist?(app_path)
+
+      joined_app_path = File.join(Gym.config[:output_directory], File.basename(app_path))
+      FileUtils.rm_rf(joined_app_path)
+      FileUtils.cp_r(app_path, File.expand_path(Gym.config[:output_directory]), remove_destination: true)
+
+      UI.success("Successfully exported the .app file:")
+      UI.message(joined_app_path)
+      joined_app_path
+    end
+
+    # Move the manifest.plist if exists into the output directory
+    def move_manifest
+      if File.exist?(PackageCommandGenerator.manifest_path)
+        FileUtils.mv(PackageCommandGenerator.manifest_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        manifest_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.manifest_path))
+
+        UI.success("Successfully exported the manifest.plist file:")
+        UI.message(manifest_path)
+        manifest_path
+      end
+    end
+
+    # Move the app-thinning.plist file into the output directory
+    def move_app_thinning
+      if File.exist?(PackageCommandGenerator.app_thinning_path)
+        FileUtils.mv(PackageCommandGenerator.app_thinning_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        app_thinning_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.app_thinning_path))
+
+        UI.success("Successfully exported the app-thinning.plist file:")
+        UI.message(app_thinning_path)
+        app_thinning_path
+      end
+    end
+
+    # Move the App Thinning Size Report.txt file into the output directory
+    def move_app_thinning_size_report
+      if File.exist?(PackageCommandGenerator.app_thinning_size_report_path)
+        FileUtils.mv(PackageCommandGenerator.app_thinning_size_report_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        app_thinning_size_report_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.app_thinning_size_report_path))
+
+        UI.success("Successfully exported the App Thinning Size Report.txt file:")
+        UI.message(app_thinning_size_report_path)
+        app_thinning_size_report_path
+      end
+    end
+
+    # Move the Apps folder to the output directory
+    def move_apps_folder
+      if Dir.exist?(PackageCommandGenerator.apps_path)
+        FileUtils.mv(PackageCommandGenerator.apps_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        apps_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.apps_path))
+
+        UI.success("Successfully exported Apps folder:")
+        UI.message(apps_path)
+        apps_path
+      end
+    end
+
+    # Move Asset Packs folder to the output directory
+    # @return (String) The path to the resulting Asset Packs (aka OnDemandResources) folder
+    def move_asset_packs
+      if Dir.exist?(PackageCommandGenerator.asset_packs_path)
+        FileUtils.mv(PackageCommandGenerator.asset_packs_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        asset_packs_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.asset_packs_path))
+
+        UI.success("Successfully exported Asset Pack folder:")
+        UI.message(asset_packs_path)
+        asset_packs_path
+      end
+    end
+
+    # Move the AppStoreInfo.plist folder to the output directory
+    def move_appstore_info
+      if File.exist?(PackageCommandGenerator.appstore_info_path)
+        FileUtils.mv(PackageCommandGenerator.appstore_info_path, File.expand_path(Gym.config[:output_directory]), force: true)
+        appstore_info_path = File.join(File.expand_path(Gym.config[:output_directory]), File.basename(PackageCommandGenerator.appstore_info_path))
+
+        UI.success("Successfully exported the AppStoreInfo.plist file:")
+        UI.message(appstore_info_path)
+        appstore_info_path
+      end
+    end
+
+    def find_archive_path
+      Dir.glob(File.join(BuildCommandGenerator.build_path, "*.ipa")).last
+    end
+  end
+end