fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/xcode_select.rb

@@ -0,0 +1,68 @@
+module Fastlane
+  module Actions
+    # See: https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/xcode-select.1.html
+    #
+    # DESCRIPTION
+    #   xcode-select controls the location of the developer directory used by xcrun(1), xcodebuild(1), cc(1),
+    #   and other Xcode and BSD development tools. This also controls the locations that are searched for  by
+    #   man(1) for developer tool manpages.
+    #
+    # DEVELOPER_DIR
+    #   Overrides the active developer directory. When DEVELOPER_DIR  is  set,  its  value  will  be  used
+    #   instead of the system-wide active developer directory.
+    #
+    #   Note that for historical reason, the developer directory is considered to be the Developer content
+    #   directory inside the Xcode application (for  example  /Applications/Xcode.app/Contents/Developer).
+    #   You  can  set  the  environment variable to either the actual Developer contents directory, or the
+    #   Xcode application directory -- the xcode-select provided  shims  will  automatically  convert  the
+    #   environment variable into the full Developer content path.
+    #
+    class XcodeSelectAction < Action
+      def self.run(params)
+        params = nil unless params.kind_of?(Array)
+        xcode_path = (params || []).first
+
+        # Verify that a param was passed in
+        UI.user_error!("Path to Xcode application required (e.g. `xcode_select(\"/Applications/Xcode.app\")`)") unless xcode_path.to_s.length > 0
+
+        # Verify that a path to a directory was passed in
+        UI.user_error!("Path '#{xcode_path}' doesn't exist") unless Dir.exist?(xcode_path)
+
+        UI.message("Setting Xcode version to #{xcode_path} for all build steps")
+
+        ENV["DEVELOPER_DIR"] = File.join(xcode_path, "/Contents/Developer")
+      end
+
+      def self.description
+        "Change the xcode-path to use. Useful for beta versions of Xcode"
+      end
+
+      def self.details
+        [
+          "Select and build with the Xcode installed at the provided path.",
+          "Use the `xcversion` action if you want to select an Xcode:",
+          "- Based on a version specifier or",
+          "- You don't have known, stable paths, as may happen in a CI environment."
+        ].join("\n")
+      end
+
+      def self.author
+        "dtrenz"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xcode_select("/Applications/Xcode-8.3.2.app")'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/xcode_server_get_assets.rb

@@ -0,0 +1,312 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      XCODE_SERVER_GET_ASSETS_PATH = :XCODE_SERVER_GET_ASSETS_PATH
+      XCODE_SERVER_GET_ASSETS_ARCHIVE_PATH = :XCODE_SERVER_GET_ASSETS_ARCHIVE_PATH
+    end
+
+    class XcodeServerGetAssetsAction < Action
+      require 'excon'
+      require 'json'
+      require 'fileutils'
+
+      def self.run(params)
+        host = params[:host]
+        bot_name = params[:bot_name]
+        integration_number_override = params[:integration_number]
+        target_folder = params[:target_folder]
+        keep_all_assets = params[:keep_all_assets]
+        username = params[:username]
+        password = params[:password]
+        trust_self_signed_certs = params[:trust_self_signed_certs]
+
+        # setup (not)trusting self signed certificates.
+        # it's normal to have a self signed certificate on your Xcode Server
+        Excon.defaults[:ssl_verify_peer] = !trust_self_signed_certs # for self-signed certificates
+
+        # create Xcode Server config
+        xcs = XcodeServer.new(host, username, password)
+        bots = xcs.fetch_all_bots
+
+        UI.important("Fetched #{bots.count} Bots from Xcode Server at #{host}.")
+
+        # pull out names
+        bot_names = bots.map { |bot| bot['name'] }
+
+        # match the bot name with a found bot, otherwise fail
+        found_bots = bots.select { |bot| bot['name'] == bot_name }
+        UI.user_error!("Failed to find a Bot with name #{bot_name} on server #{host}, only available Bots: #{bot_names}") if found_bots.count == 0
+
+        bot = found_bots[0]
+
+        UI.success("Found Bot with name #{bot_name} with id #{bot['_id']}.")
+
+        # we have our bot, get finished integrations, sorted from newest to oldest
+        integrations = xcs.fetch_integrations(bot['_id']).select { |i| i['currentStep'] == 'completed' }
+        UI.user_error!("Failed to find any completed integration for Bot \"#{bot_name}\"") if (integrations || []).count == 0
+
+        # if no integration number is specified, pick the newest one (this is sorted from newest to oldest)
+        if integration_number_override
+          integration = integrations.find { |i| i['number'] == integration_number_override }
+          UI.user_error!("Specified integration number #{integration_number_override} does not exist.") unless integration
+        else
+          integration = integrations.first
+        end
+
+        # consider: only taking the last successful one? or allow failing tests? warnings?
+
+        UI.important("Using integration #{integration['number']}.")
+
+        # fetch assets for this integration
+        assets_path = xcs.fetch_assets(integration['_id'], target_folder, self)
+        UI.user_error!("Failed to fetch assets for integration #{integration['number']}.") unless assets_path
+
+        asset_entries = Dir.entries(assets_path).map { |i| File.join(assets_path, i) }
+
+        UI.success("Successfully downloaded #{asset_entries.count} assets to file #{assets_path}!")
+
+        # now find the archive and unzip it
+        zipped_archive_path = asset_entries.find { |i| i.end_with?('xcarchive.zip') }
+
+        if zipped_archive_path
+
+          UI.important("Found an archive in the assets folder...")
+
+          archive_file_path = File.basename(zipped_archive_path, File.extname(zipped_archive_path))
+          archive_dir_path = File.dirname(zipped_archive_path)
+          archive_path = File.join(archive_dir_path, archive_file_path)
+          if File.exist?(archive_path)
+            # we already have the archive, skip
+            UI.important("Archive #{archive_path} already exists, not unzipping again...")
+          else
+            # unzip the archive
+            sh("unzip -q \"#{zipped_archive_path}\" -d \"#{archive_dir_path}\"")
+          end
+
+          # reload asset entries to also contain the xcarchive file
+          asset_entries = Dir.entries(assets_path).map { |i| File.join(assets_path, i) }
+
+          # optionally delete everything except for the archive
+          unless keep_all_assets
+            files_to_delete = asset_entries.select do |i|
+              File.extname(i) != '.xcarchive' && ![".", ".."].include?(File.basename(i))
+            end
+
+            files_to_delete.each do |i|
+              FileUtils.rm_rf(i)
+            end
+          end
+
+          Actions.lane_context[SharedValues::XCODE_SERVER_GET_ASSETS_ARCHIVE_PATH] = archive_path
+        end
+
+        Actions.lane_context[SharedValues::XCODE_SERVER_GET_ASSETS_PATH] = assets_path
+
+        return assets_path
+      end
+
+      class XcodeServer
+        def initialize(host, username, password)
+          @host = host.start_with?('https://') ? host : "https://#{host}"
+          @username = username
+          @password = password
+        end
+
+        def fetch_all_bots
+          response = get_endpoint('/bots')
+          UI.user_error!("You are unauthorized to access data on #{@host}, please check that you're passing in a correct username and password.") if response.status == 401
+          UI.user_error!("Failed to fetch Bots from Xcode Server at #{@host}, response: #{response.status}: #{response.body}.") if response.status != 200
+          JSON.parse(response.body)['results']
+        end
+
+        def fetch_integrations(bot_id)
+          response = get_endpoint("/bots/#{bot_id}/integrations?last=10")
+          UI.user_error!("Failed to fetch Integrations for Bot #{bot_id} from Xcode Server at #{@host}, response: #{response.status}: #{response.body}") if response.status != 200
+          JSON.parse(response.body)['results']
+        end
+
+        def fetch_assets(integration_id, target_folder, action)
+          # create a temp folder and a file, stream the download into it
+          Dir.mktmpdir do |dir|
+            temp_file = File.join(dir, "tmp_download.#{rand(1_000_000)}")
+            f = open(temp_file, 'w')
+            streamer = lambda do |chunk, remaining_bytes, total_bytes|
+              if remaining_bytes && total_bytes
+                UI.important("Downloading: #{100 - (100 * remaining_bytes.to_f / total_bytes.to_f).to_i}%")
+              else
+                UI.error(chunk.to_s)
+              end
+              f.write(chunk)
+            end
+
+            response = self.get_endpoint("/integrations/#{integration_id}/assets", streamer)
+            f.close
+
+            UI.user_error!("Integration doesn't have any assets (it probably never ran).") if response.status == 500
+            UI.user_error!("Failed to fetch Assets zip for Integration #{integration_id} from Xcode Server at #{@host}, response: #{response.status}: #{response.body}") if response.status != 200
+
+            # unzip it, it's a .tar.gz file
+            out_folder = File.join(dir, "out_#{rand(1_000_000)}")
+            FileUtils.mkdir_p(out_folder)
+
+            action.sh("cd \"#{out_folder}\"; cat \"#{temp_file}\" | gzip -d | tar -x")
+
+            # then pull the real name from headers
+            asset_filename = response.headers['Content-Disposition'].split(';')[1].split('=')[1].delete('"')
+            asset_foldername = asset_filename.split('.')[0]
+
+            # rename the folder in out_folder to asset_foldername
+            found_folder = Dir.entries(out_folder).select { |item| item != '.' && item != '..' }[0]
+
+            UI.user_error!("Internal error, couldn't find unzipped folder") if found_folder.nil?
+
+            unzipped_folder_temp_name = File.join(out_folder, found_folder)
+            unzipped_folder = File.join(out_folder, asset_foldername)
+
+            # rename to destination name
+            FileUtils.mv(unzipped_folder_temp_name, unzipped_folder)
+
+            target_folder = File.absolute_path(target_folder)
+
+            # create target folder if it doesn't exist
+            FileUtils.mkdir_p(target_folder)
+
+            # and move+rename it to the destination place
+            FileUtils.cp_r(unzipped_folder, target_folder)
+            out = File.join(target_folder, asset_foldername)
+            return out
+          end
+          return nil
+        end
+
+        def headers
+          require 'base64'
+          headers = {
+            'User-Agent' => 'fastlane-xcode_server_get_assets', # XCS wants user agent. for some API calls. not for others. sigh.
+            'X-XCSAPIVersion' => 1 # XCS API version with this API, Xcode needs this otherwise it explodes in a 500 error fire. Currently Xcode 7 Beta 5 is on Version 5.
+          }
+
+          if @username && @password
+            userpass = "#{@username}:#{@password}"
+            headers['Authorization'] = "Basic #{Base64.strict_encode64(userpass)}"
+          end
+
+          return headers
+        end
+
+        def get_endpoint(endpoint, response_block = nil)
+          url = url_for_endpoint(endpoint)
+          headers = self.headers || {}
+
+          if response_block
+            response = Excon.get(url, response_block: response_block, headers: headers)
+          else
+            response = Excon.get(url, headers: headers)
+          end
+
+          return response
+        end
+
+        private
+
+        def url_for_endpoint(endpoint)
+          "#{@host}:20343/api#{endpoint}"
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Downloads Xcode Bot assets like the `.xcarchive` and logs"
+      end
+
+      def self.details
+        [
+          "This action downloads assets from your Xcode Server Bot (works with Xcode Server using Xcode 6 and 7. By default, this action downloads all assets, unzips them and deletes everything except for the `.xcarchive`.",
+          "If you'd like to keep all downloaded assets, pass `keep_all_assets: true`.",
+          "This action returns the path to the downloaded assets folder and puts into shared values the paths to the asset folder and to the `.xcarchive` inside it."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :host,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_HOST",
+                                       description: "IP Address/Hostname of Xcode Server",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :bot_name,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_BOT_NAME",
+                                       description: "Name of the Bot to pull assets from",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :integration_number,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_INTEGRATION_NUMBER",
+                                       description: "Optionally you can override which integration's assets should be downloaded. If not provided, the latest integration is used",
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_USERNAME",
+                                       description: "Username for your Xcode Server",
+                                       optional: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_PASSWORD",
+                                       description: "Password for your Xcode Server",
+                                       sensitive: true,
+                                       optional: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :target_folder,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_TARGET_FOLDER",
+                                       description: "Relative path to a folder into which to download assets",
+                                       optional: true,
+                                       default_value: './xcs_assets'),
+          FastlaneCore::ConfigItem.new(key: :keep_all_assets,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_KEEP_ALL_ASSETS",
+                                       description: "Whether to keep all assets or let the script delete everything except for the .xcarchive",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :trust_self_signed_certs,
+                                       env_name: "FL_XCODE_SERVER_GET_ASSETS_TRUST_SELF_SIGNED_CERTS",
+                                       description: "Whether to trust self-signed certs on your Xcode Server",
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['XCODE_SERVER_GET_ASSETS_PATH', 'Absolute path to the downloaded assets folder'],
+          ['XCODE_SERVER_GET_ASSETS_ARCHIVE_PATH', 'Absolute path to the downloaded xcarchive file']
+        ]
+      end
+
+      def self.return_type
+        :array_of_strings
+      end
+
+      def self.authors
+        ["czechboy0"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xcode_server_get_assets(
+            host: "10.99.0.59", # Specify Xcode Server\'s Host or IP Address
+            bot_name: "release-1.3.4" # Specify the particular Bot
+          )'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/xcodebuild.rb

@@ -0,0 +1,641 @@
+# rubocop:disable all
+module Fastlane
+  module Actions
+    module SharedValues
+      XCODEBUILD_ARCHIVE ||= :XCODEBUILD_ARCHIVE
+      XCODEBUILD_DERIVED_DATA_PATH = :XCODEBUILD_DERIVED_DATA_PATH
+    end
+
+    # xcodebuild man page:
+    # https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/xcodebuild.1.html
+
+    class XcodebuildAction < Action
+      ARGS_MAP = {
+        # actions
+        analyze: "analyze",
+        archive: "archive",
+        build: "build",
+        clean: "clean",
+        install: "install",
+        installsrc: "installsrc",
+        test: "test",
+
+        # parameters
+        alltargets: "-alltargets",
+        arch: "-arch",
+        archive_path: "-archivePath",
+        configuration: "-configuration",
+        derivedDataPath: "-derivedDataPath",
+        destination_timeout: "-destination-timeout",
+        dry_run: "-dry-run",
+        enableAddressSanitizer: "-enableAddressSanitizer",
+        enableThreadSanitizer: "-enableThreadSanitizer",
+        enableCodeCoverage: "-enableCodeCoverage",
+        export_archive: "-exportArchive",
+        export_format: "-exportFormat",
+        export_installer_identity: "-exportInstallerIdentity",
+        export_options_plist: "-exportOptionsPlist",
+        export_path: "-exportPath",
+        export_profile: "-exportProvisioningProfile",
+        export_signing_identity: "-exportSigningIdentity",
+        export_with_original_signing_identity: "-exportWithOriginalSigningIdentity",
+        hide_shell_script_environment: "-hideShellScriptEnvironment",
+        jobs: "-jobs",
+        parallelize_targets: "-parallelizeTargets",
+        project: "-project",
+        result_bundle_path: "-resultBundlePath",
+        scheme: "-scheme",
+        sdk: "-sdk",
+        skip_unavailable_actions: "-skipUnavailableActions",
+        target: "-target",
+        toolchain: "-toolchain",
+        workspace: "-workspace",
+        xcconfig: "-xcconfig"
+      }
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+
+      def self.example_code
+        [
+          'xcodebuild(
+            archive: true,
+            archive_path: "./build-dir/MyApp.xcarchive",
+            scheme: "MyApp",
+            workspace: "MyApp.xcworkspace"
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.run(params)
+        unless Helper.test?
+          UI.user_error!("xcodebuild not installed") if `which xcodebuild`.length == 0
+        end
+
+        # The args we will build with
+        xcodebuild_args = Array[]
+
+        # Supported ENV vars
+        build_path    = ENV["XCODE_BUILD_PATH"] || nil
+        scheme        = ENV["XCODE_SCHEME"]
+        workspace     = ENV["XCODE_WORKSPACE"]
+        project       = ENV["XCODE_PROJECT"]
+        buildlog_path = ENV["XCODE_BUILDLOG_PATH"]
+
+        # Set derived data path.
+        params[:derivedDataPath] ||= ENV["XCODE_DERIVED_DATA_PATH"]
+        Actions.lane_context[SharedValues::XCODEBUILD_DERIVED_DATA_PATH] = params[:derivedDataPath]
+
+        # Append slash to build path, if needed
+        if build_path && !build_path.end_with?("/")
+          build_path += "/"
+        end
+
+        # By default we use xcpretty
+        raw_buildlog = false
+
+        # By default we don't pass the utf flag
+        xcpretty_utf = false
+
+        if params
+          # Operation bools
+          archiving    = params.key? :archive
+          exporting    = params.key? :export_archive
+          testing      = params.key? :test
+          xcpretty_utf = params[:xcpretty_utf]
+
+          if params.key? :raw_buildlog
+            raw_buildlog = params[:raw_buildlog]
+          end
+
+          if exporting
+            # If not passed, retrieve path from previous xcodebuild call
+            params[:archive_path] ||= Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE]
+
+            # If not passed, construct export path from env vars
+            if params[:export_path].nil?
+              ipa_filename = scheme ? scheme : File.basename(params[:archive_path], ".*")
+              params[:export_path] = "#{build_path}#{ipa_filename}"
+            end
+
+            # Default to ipa as export format
+            export_format = params[:export_format] || "ipa"
+
+            # Store IPA path for later deploy steps (i.e. Crashlytics)
+            Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] = params[:export_path] + "." + export_format.downcase
+          else
+            # If not passed, check for archive scheme & workspace/project env vars
+            params[:scheme] ||= scheme
+            params[:workspace] ||= workspace
+            params[:project] ||= project
+
+            # If no project or workspace was passed in or set as an environment
+            # variable, attempt to autodetect the workspace.
+            if params[:project].to_s.empty? && params[:workspace].to_s.empty?
+              params[:workspace] = detect_workspace
+            end
+          end
+
+          if archiving
+            # If not passed, construct archive path from env vars
+            params[:archive_path] ||= "#{build_path}#{params[:scheme]}.xcarchive"
+
+            # Cache path for later xcodebuild calls
+            Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE] = params[:archive_path]
+          end
+
+          if params.key? :enable_address_sanitizer
+            params[:enableAddressSanitizer] = params[:enable_address_sanitizer] ? 'YES' : 'NO'
+          end
+          if params.key? :enable_thread_sanitizer
+            params[:enableThreadSanitizer] = params[:enable_thread_sanitizer] ? 'YES' : 'NO'
+          end
+          if params.key? :enable_code_coverage
+            params[:enableCodeCoverage] = params[:enable_code_coverage] ? 'YES' : 'NO'
+          end
+
+          # Maps parameter hash to CLI args
+          params = export_options_to_plist(params)
+          if hash_args = hash_to_args(params)
+            xcodebuild_args += hash_args
+          end
+
+          buildlog_path ||= params[:buildlog_path]
+        end
+
+        # By default we put xcodebuild.log in the Logs folder
+        buildlog_path ||= File.expand_path("#{FastlaneCore::Helper.buildlog_path}/fastlane/xcbuild/#{Time.now.strftime('%F')}/#{Process.pid}")
+
+        # Joins args into space delimited string
+        xcodebuild_args = xcodebuild_args.join(" ")
+
+        # Default args
+        xcpretty_args = []
+
+        # Formatting style
+        if params && params[:output_style]
+          output_style = params[:output_style]
+          UI.user_error!("Invalid output_style #{output_style}") unless [:standard, :basic].include?(output_style)
+        else
+          output_style = :standard
+        end
+
+        case output_style
+        when :standard
+          xcpretty_args << '--color' unless Helper.colors_disabled?
+        when :basic
+          xcpretty_args << '--no-utf'
+        end
+
+        if testing
+          if params[:reports]
+            # New report options format
+            reports = params[:reports].reduce("") do |arguments, report|
+              report_string = "--report #{report[:report]}"
+
+              if report[:output]
+                report_string << " --output \"#{report[:output]}\""
+              elsif report[:report] == 'junit'
+                report_string << " --output \"#{build_path}report/report.xml\""
+              elsif report[:report] == 'html'
+                report_string << " --output \"#{build_path}report/report.html\""
+              elsif report[:report] == 'json-compilation-database'
+                report_string << " --output \"#{build_path}report/report.json\""
+              end
+
+              if report[:screenshots]
+                report_string << " --screenshots"
+              end
+
+              unless arguments == ""
+                arguments << " "
+              end
+
+              arguments << report_string
+            end
+
+            xcpretty_args.push reports
+
+          elsif params[:report_formats]
+            # Test report file format
+            report_formats = params[:report_formats].map do |format|
+              "--report #{format}"
+            end.sort.join(" ")
+
+            xcpretty_args.push report_formats
+
+            # Save screenshots flag
+            if params[:report_formats].include?("html") && params[:report_screenshots]
+              xcpretty_args.push "--screenshots"
+            end
+
+            xcpretty_args.sort!
+
+            # Test report file path
+            if params[:report_path]
+              xcpretty_args.push "--output \"#{params[:report_path]}\""
+            elsif build_path
+              xcpretty_args.push "--output \"#{build_path}report\""
+            end
+          end
+        end
+
+        # Stdout format
+        if testing && !archiving
+          xcpretty_args << (params[:xcpretty_output] ? "--#{params[:xcpretty_output]}" : "--test")
+        else
+          xcpretty_args << (params[:xcpretty_output] ? "--#{params[:xcpretty_output]}" : "--simple")
+        end
+
+        xcpretty_args = xcpretty_args.join(" ")
+
+        xcpretty_command = ""
+        xcpretty_command = "| xcpretty #{xcpretty_args}" unless raw_buildlog
+        unless raw_buildlog
+          xcpretty_command = "#{xcpretty_command} --utf" if xcpretty_utf
+        end
+
+        pipe_command = "| tee '#{buildlog_path}/xcodebuild.log' #{xcpretty_command}"
+
+        FileUtils.mkdir_p buildlog_path
+        UI.message("For a more detailed xcodebuild log open #{buildlog_path}/xcodebuild.log")
+
+        output_result = ""
+
+        # In some cases the simulator is not booting up in time
+        # One way to solve it is to try to rerun it for one more time
+        begin
+          output_result = Actions.sh "set -o pipefail && xcodebuild #{xcodebuild_args} #{pipe_command}"
+        rescue => ex
+          exit_status = $?.exitstatus
+
+          raise_error = true
+          if exit_status.eql? 65
+            iphone_simulator_time_out_error = /iPhoneSimulator: Timed out waiting/
+
+            if (iphone_simulator_time_out_error =~ ex.message) != nil
+              raise_error = false
+
+              UI.important("First attempt failed with iPhone Simulator error: #{iphone_simulator_time_out_error.source}")
+              UI.important("Retrying once more...")
+              output_result = Actions.sh "set -o pipefail && xcodebuild #{xcodebuild_args} #{pipe_command}"
+            end
+          end
+
+          raise ex if raise_error
+        end
+
+        # If raw_buildlog and some reports had to be created, create xcpretty reports from the build log
+        if raw_buildlog && xcpretty_args.include?('--report')
+          output_result = Actions.sh "set -o pipefail && cat '#{buildlog_path}/xcodebuild.log' | xcpretty #{xcpretty_args} > /dev/null"
+        end
+
+        output_result
+      end
+
+      def self.export_options_to_plist(hash)
+        # Extract export options parameters from input options
+        if hash.has_key?(:export_options_plist) && hash[:export_options_plist].is_a?(Hash)
+          export_options = hash[:export_options_plist]
+
+          # Normalize some values
+          export_options[:teamID] = CredentialsManager::AppfileConfig.try_fetch_value(:team_id) if !export_options[:teamID] && CredentialsManager::AppfileConfig.try_fetch_value(:team_id)
+          export_options[:onDemandResourcesAssetPacksBaseURL] = URI.escape(export_options[:onDemandResourcesAssetPacksBaseURL]) if export_options[:onDemandResourcesAssetPacksBaseURL]
+          if export_options[:manifest]
+            export_options[:manifest][:appURL] = URI.encode_www_form_component(export_options[:manifest][:appURL]) if export_options[:manifest][:appURL]
+            export_options[:manifest][:displayImageURL] = URI.encode_www_form_component(export_options[:manifest][:displayImageURL]) if export_options[:manifest][:displayImageURL]
+            export_options[:manifest][:fullSizeImageURL] = URI.encode_www_form_component(export_options[:manifest][:fullSizeImageURL]) if export_options[:manifest][:fullSizeImageURL]
+            export_options[:manifest][:assetPackManifestURL] = URI.encode_www_form_component(export_options[:manifest][:assetPackManifestURL]) if export_options[:manifest][:assetPackManifestURL]
+          end
+
+          # Saves options to plist
+          path = "#{Tempfile.new('exportOptions').path}.plist"
+          File.write(path, export_options.to_plist)
+          hash[:export_options_plist] = path
+        end
+        hash
+      end
+
+      def self.hash_to_args(hash)
+        # Remove nil value params
+        hash = hash.delete_if { |_, v| v.nil? }
+
+        # Maps nice developer param names to CLI arguments
+        hash.map do |k, v|
+          v ||= ""
+          if arg = ARGS_MAP[k]
+            value = (v != true && v.to_s.length > 0 ? "\"#{v}\"" : "")
+            "#{arg} #{value}".strip
+          elsif k == :build_settings
+            v.map do |setting, val|
+              val = clean_build_setting_value(val)
+              "#{setting}=\"#{val}\""
+            end.join(' ')
+          elsif k == :destination
+            [*v].collect { |dst| "-destination \"#{dst}\"" }.join(' ')
+          elsif k == :keychain && v.to_s.length > 0
+            # If keychain is specified, append as OTHER_CODE_SIGN_FLAGS
+            "OTHER_CODE_SIGN_FLAGS=\"--keychain #{v}\""
+          elsif k == :xcargs && v.to_s.length > 0
+            # Add more xcodebuild arguments
+            "#{v}"
+          end
+        end.compact
+      end
+
+      # Cleans values for build settings
+      # Only escaping `$(inherit)` types of values since "sh"
+      # interprets these as sub-commands instead of passing value into xcodebuild
+      def self.clean_build_setting_value(value)
+        value.to_s.gsub('$(', '\\$(')
+      end
+
+      def self.detect_workspace
+        workspace = nil
+        workspaces = Dir.glob("*.xcworkspace")
+
+        if workspaces.length > 1
+          UI.important("Multiple workspaces detected.")
+        end
+
+        unless workspaces.empty?
+          workspace = workspaces.first
+          UI.important("Using workspace \"#{workspace}\"")
+        end
+
+        return workspace
+      end
+
+      def self.description
+        "Use the `xcodebuild` command to build and sign your app"
+      end
+
+      def self.available_options
+        [
+          ['archive', 'Set to true to build archive'],
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+
+      def self.details
+        "**Note**: `xcodebuild` is a complex command, so it is recommended to use [_gym_](https://docs.fastlane.tools/actions/gym/) for building your ipa file and [_scan_](https://docs.fastlane.tools/actions/scan/) for testing your app instead."
+      end
+
+      def self.author
+        "dtrenz"
+      end
+    end
+
+    class XcarchiveAction < Action
+      def self.run(params)
+        params_hash = params || {}
+        params_hash[:archive] = true
+        XcodebuildAction.run(params_hash)
+      end
+
+      def self.description
+        "Archives the project using `xcodebuild`"
+      end
+
+      def self.example_code
+        [
+          'xcarchive'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.author
+        "dtrenz"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+
+      def self.available_options
+        [
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+    end
+
+    class XcbuildAction < Action
+      def self.run(params)
+        params_hash = params || {}
+        params_hash[:build] = true
+        XcodebuildAction.run(params_hash)
+      end
+
+      def self.example_code
+        [
+          'xcbuild'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.description
+        "Builds the project using `xcodebuild`"
+      end
+
+      def self.author
+        "dtrenz"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+
+      def self.available_options
+        [
+          ['archive', 'Set to true to build archive'],
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+    end
+
+    class XccleanAction < Action
+      def self.run(params)
+        params_hash = params || {}
+        params_hash[:clean] = true
+        XcodebuildAction.run(params_hash)
+      end
+
+      def self.description
+        "Cleans the project using `xcodebuild`"
+      end
+
+      def self.example_code
+        [
+          'xcclean'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.author
+        "dtrenz"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+
+      def self.available_options
+        [
+          ['archive', 'Set to true to build archive'],
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+    end
+
+    class XcexportAction < Action
+      def self.run(params)
+        params_hash = params || {}
+        params_hash[:export_archive] = true
+        XcodebuildAction.run(params_hash)
+      end
+
+      def self.description
+        "Exports the project using `xcodebuild`"
+      end
+
+      def self.example_code
+        [
+          'xcexport'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.author
+        "dtrenz"
+      end
+
+      def self.available_options
+        [
+          ['archive', 'Set to true to build archive'],
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+    end
+
+    class XctestAction < Action
+      def self.run(params)
+        UI.important("Have you seen the new 'scan' tool to run tests? https://docs.fastlane.tools/actions/scan/")
+        params_hash = params || {}
+        params_hash[:build] = true
+        params_hash[:test] = true
+
+        XcodebuildAction.run(params_hash)
+      end
+
+      def self.example_code
+        [
+          'xctest(
+            destination: "name=iPhone 7s,OS=10.0"
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.description
+        "Runs tests on the given simulator"
+      end
+
+      def self.available_options
+        [
+          ['archive', 'Set to true to build archive'],
+          ['archive_path', 'The path to archive the to. Must contain `.xcarchive`'],
+          ['workspace', 'The workspace to use'],
+          ['scheme', 'The scheme to build'],
+          ['build_settings', 'Hash of additional build information'],
+          ['xcargs', 'Pass additional xcodebuild options'],
+          ['destination', 'The simulator to use, e.g. "name=iPhone 5s,OS=8.1"'],
+          ['destination_timeout', 'The timeout for connecting to the simulator, in seconds'],
+          ['enable_code_coverage', 'Turn code coverage on or off when testing. eg. true|false. Requires Xcode 7+'],
+          ['output_style', 'Set the output format to one of: :standard (Colored UTF8 output, default), :basic (black & white ASCII output)'],
+          ['buildlog_path', 'The path where the xcodebuild.log will be created, by default it is created in ~/Library/Logs/fastlane/xcbuild'],
+          ['raw_buildlog', 'Set to true to see xcodebuild raw output. Default value is false'],
+          ['xcpretty_output', 'specifies the output type for xcpretty. eg. \'test\', or \'simple\''],
+          ['xcpretty_utf', 'Specifies xcpretty should use utf8 when reporting builds. This has no effect when raw_buildlog is specified.']
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include? platform
+      end
+
+      def self.author
+        "dtrenz"
+      end
+    end
+  end
+end
+# rubocop:enable all