fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/register_devices.rb

@@ -0,0 +1,214 @@
+require 'credentials_manager'
+
+module Fastlane
+  module Actions
+    class RegisterDevicesAction < Action
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.file_column_headers
+        ['Device ID', 'Device Name', 'Device Platform']
+      end
+
+      def self.run(params)
+        platform = Spaceship::ConnectAPI::BundleIdPlatform.map(params[:platform])
+
+        if params[:devices]
+          new_devices = params[:devices].map do |name, udid|
+            [udid, name]
+          end
+        elsif params[:devices_file]
+          require 'csv'
+
+          devices_file = CSV.read(File.expand_path(File.join(params[:devices_file])), col_sep: "\t")
+          unless devices_file.first == file_column_headers.first(2) || devices_file.first == file_column_headers
+            UI.user_error!("Please provide a file according to the Apple Sample UDID file (https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip)")
+          end
+
+          new_devices = devices_file.drop(1).map do |row|
+            if row.count == 1
+              UI.user_error!("Invalid device line, ensure you are using tabs (NOT spaces). See Apple's sample/spec here: https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip")
+            elsif !(2..3).cover?(row.count)
+              UI.user_error!("Invalid device line, please provide a file according to the Apple Sample UDID file (https://developer.apple.com/account/resources/downloads/Multiple-Upload-Samples.zip)")
+            end
+            row
+          end
+        else
+          UI.user_error!("You must pass either a valid `devices` or `devices_file`. Please check the readme.")
+        end
+
+        require 'spaceship'
+        if (token = api_token(params))
+          UI.message("Using App Store Connect API token...")
+          Spaceship::ConnectAPI.token = token
+        else
+          UI.message("Login to App Store Connect (#{params[:username]})")
+          credentials = CredentialsManager::AccountManager.new(user: params[:username])
+          Spaceship::ConnectAPI.login(credentials.user, credentials.password, use_portal: true, use_tunes: false)
+          UI.message("Login successful")
+        end
+
+        UI.message("Fetching list of currently registered devices...")
+        existing_devices = Spaceship::ConnectAPI::Device.all
+
+        device_objs = new_devices.map do |device|
+          if existing_devices.map(&:udid).map(&:downcase).include?(device[0].downcase)
+            UI.verbose("UDID #{device[0]} already exists - Skipping...")
+            next
+          end
+
+          device_platform = platform
+
+          device_platform_supported = !device[2].nil? && self.is_supported?(device[2].to_sym)
+          if device_platform_supported
+            if device[2] == "mac"
+              device_platform = Spaceship::ConnectAPI::BundleIdPlatform::MAC_OS
+            else
+              device_platform = Spaceship::ConnectAPI::BundleIdPlatform::IOS
+            end
+          end
+
+          try_create_device(name: device[1], platform: device_platform, udid: device[0])
+        end
+
+        UI.success("Successfully registered new devices.")
+        return device_objs
+      end
+
+      def self.try_create_device(name: nil, platform: nil, udid: nil)
+        Spaceship::ConnectAPI::Device.create(name: name, platform: platform, udid: udid)
+      rescue => ex
+        UI.error(ex.to_s)
+        UI.crash!("Failed to register new device (name: #{name}, UDID: #{udid})")
+      end
+
+      def self.api_token(params)
+        params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+        api_token ||= Spaceship::ConnectAPI::Token.create(params[:api_key]) if params[:api_key]
+        api_token ||= Spaceship::ConnectAPI::Token.from_json_file(params[:api_key_path]) if params[:api_key_path]
+        return api_token
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Registers new devices to the Apple Dev Portal"
+      end
+
+      def self.available_options
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME].to_s
+
+        [
+          FastlaneCore::ConfigItem.new(key: :devices,
+                                       env_name: "FL_REGISTER_DEVICES_DEVICES",
+                                       description: "A hash of devices, with the name as key and the UDID as value",
+                                       is_string: false,
+                                       type: Hash,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :devices_file,
+                                       env_name: "FL_REGISTER_DEVICES_FILE",
+                                       description: "Provide a path to a file with the devices to register. For the format of the file see the examples",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find file '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_name: "FL_REGISTER_DEVICES_API_KEY_PATH",
+                                       description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "FL_REGISTER_DEVICES_API_KEY",
+                                       description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#use-return-value-and-pass-in-as-an-option)",
+                                       type: Hash,
+                                       optional: true,
+                                       sensitive: true,
+                                       conflicting_options: [:api_key_path]),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                     env_name: "REGISTER_DEVICES_TEAM_ID",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                       default_value_dynamic: true,
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       env_name: "REGISTER_DEVICES_TEAM_NAME",
+                                       description: "The name of your Developer Portal team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "DELIVER_USER",
+                                       description: "Optional: Your Apple ID",
+                                       default_value: user,
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "REGISTER_DEVICES_PLATFORM",
+                                       description: "The platform to use (optional)",
+                                       optional: true,
+                                       default_value: platform.empty? ? "ios" : platform,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The platform can only be ios or mac") unless %('ios', 'mac').include?(value)
+                                       end)
+        ]
+      end
+
+      def self.details
+        [
+          "This will register iOS/Mac devices with the Developer Portal so that you can include them in your provisioning profiles.",
+          "This is an optimistic action, in that it will only ever add new devices to the member center, and never remove devices. If a device which has already been registered within the member center is not passed to this action, it will be left alone in the member center and continue to work.",
+          "The action will connect to the Apple Developer Portal using the username you specified in your `Appfile` with `apple_id`, but you can override it using the `username` option, or by setting the env variable `ENV['DELIVER_USER']`."
+        ].join("\n")
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.example_code
+        [
+          'register_devices(
+            devices: {
+              "Luka iPhone 6" => "1234567890123456789012345678901234567890",
+              "Felix iPad Air 2" => "abcdefghijklmnopqrstvuwxyzabcdefghijklmn"
+            }
+          ) # Simply provide a list of devices as a Hash',
+          'register_devices(
+            devices_file: "./devices.txt"
+          ) # Alternatively provide a standard UDID export .txt file, see the Apple Sample (http://devimages.apple.com/downloads/devices/Multiple-Upload-Samples.zip)',
+          'register_devices(
+            devices_file: "./devices.txt", # You must pass in either `devices_file` or `devices`.
+            team_id: "XXXXXXXXXX",         # Optional, if you"re a member of multiple teams, then you need to pass the team ID here.
+            username: "luka@goonbee.com"   # Optional, lets you override the Apple Member Center username.
+          )',
+          'register_devices(
+            devices: {
+              "Luka MacBook" => "12345678-1234-1234-1234-123456789012",
+              "Felix MacBook Pro" => "ABCDEFGH-ABCD-ABCD-ABCD-ABCDEFGHIJKL"
+            },
+            platform: "mac"
+          ) # Register devices for Mac'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/reset_git_repo.rb

@@ -0,0 +1,121 @@
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    # Does a hard reset and clean on the repo
+    class ResetGitRepoAction < Action
+      def self.run(params)
+        if params[:force] || Actions.lane_context[SharedValues::GIT_REPO_WAS_CLEAN_ON_START]
+          paths = params[:files]
+
+          return paths if Helper.test?
+
+          if paths.nil?
+            Actions.sh('git reset --hard HEAD')
+
+            clean_options = ['q', 'f', 'd']
+            clean_options << 'x' if params[:disregard_gitignore]
+            clean_command = 'git clean' + ' -' + clean_options.join
+
+            # we want to make sure that we have an array of patterns, and no nil values
+            unless params[:exclude].kind_of?(Enumerable)
+              params[:exclude] = [params[:exclude]].compact
+            end
+
+            # attach our exclude patterns to the command
+            clean_command += ' ' + params[:exclude].map { |exclude| '-e ' + exclude.shellescape }.join(' ') unless params[:exclude].count == 0
+
+            Actions.sh(clean_command) unless params[:skip_clean]
+
+            UI.success('Git repo was reset and cleaned back to a pristine state.')
+          else
+            paths.each do |path|
+              UI.important("Couldn't find file at path '#{path}'") unless File.exist?(path)
+              Actions.sh("git checkout -- '#{path}'")
+            end
+            UI.success("Git cleaned up #{paths.count} files.")
+          end
+        else
+          UI.user_error!('This is a destructive and potentially dangerous action. To protect from data loss, please add the `ensure_git_status_clean` action to the beginning of your lane, or if you\'re absolutely sure of what you\'re doing then call this action with the :force option.')
+        end
+      end
+
+      def self.description
+        "Resets git repo to a clean state by discarding uncommitted changes"
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          You have called the `ensure_git_status_clean` action prior to calling this action. This ensures that your repo started off in a clean state, so the only things that will get destroyed by this action are files that are created as a byproduct of the fastlane run.
+        LIST
+
+        [
+          "This action will reset your git repo to a clean state, discarding any uncommitted and untracked changes. Useful in case you need to revert the repo back to a clean state, e.g. after running _fastlane_.",
+          "Untracked files like `.env` will also be deleted, unless `:skip_clean` is true.",
+          "It's a pretty drastic action so it comes with a sort of safety latch. It will only proceed with the reset if this condition is met:".markdown_preserve_newlines,
+          list
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'reset_git_repo',
+          'reset_git_repo(force: true) # If you don\'t care about warnings and are absolutely sure that you want to discard all changes. This will reset the repo even if you have valuable uncommitted changes, so use with care!',
+          'reset_git_repo(skip_clean: true) # If you want "git clean" to be skipped, thus NOT deleting untracked files like ".env". Optional, defaults to false.',
+          'reset_git_repo(
+            force: true,
+            files: [
+              "./file.txt"
+            ]
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :files,
+                                       env_name: "FL_RESET_GIT_FILES",
+                                       description: "Array of files the changes should be discarded. If not given, all files will be discarded",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass an array only") unless value.kind_of?(Array)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_RESET_GIT_FORCE",
+                                       description: "Skip verifying of previously clean state of repo. Only recommended in combination with `files` option",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :skip_clean,
+                                       env_name: "FL_RESET_GIT_SKIP_CLEAN",
+                                       description: "Skip 'git clean' to avoid removing untracked files like `.env`",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :disregard_gitignore,
+                                       env_name: "FL_RESET_GIT_DISREGARD_GITIGNORE",
+                                       description: "Setting this to true will clean the whole repository, ignoring anything in your local .gitignore. Set this to true if you want the equivalent of a fresh clone, and for all untracked and ignore files to also be removed",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :exclude,
+                                       env_name: "FL_RESET_GIT_EXCLUDE",
+                                       description: "You can pass a string, or array of, file pattern(s) here which you want to have survive the cleaning process, and remain on disk, e.g. to leave the `artifacts` directory you would specify `exclude: 'artifacts'`. Make sure this pattern is also in your gitignore! See the gitignore documentation for info on patterns",
+                                       is_string: false,
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        'lmirosevic'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/reset_simulator_contents.rb

@@ -0,0 +1,92 @@
+module Fastlane
+  module Actions
+    class ResetSimulatorContentsAction < Action
+      def self.run(params)
+        os_versions = params[:os_versions] || params[:ios]
+
+        reset_simulators(os_versions)
+      end
+
+      def self.reset_simulators(os_versions)
+        UI.verbose("Resetting simulator contents")
+
+        if os_versions
+          os_versions.each do |os_version|
+            reset_all_by_version(os_version)
+          end
+        else
+          reset_all
+        end
+
+        UI.success('Simulators reset done')
+      end
+
+      def self.reset_all_by_version(os_version)
+        FastlaneCore::Simulator.reset_all_by_version(os_version: os_version)
+        FastlaneCore::SimulatorTV.reset_all_by_version(os_version: os_version)
+        FastlaneCore::SimulatorWatch.reset_all_by_version(os_version: os_version)
+      end
+
+      def self.reset_all
+        FastlaneCore::Simulator.reset_all
+        FastlaneCore::SimulatorTV.reset_all
+        FastlaneCore::SimulatorWatch.reset_all
+      end
+
+      def self.description
+        "Shutdown and reset running simulators"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :ios,
+                                       deprecated: "Use `:os_versions` instead",
+                                       short_option: "-i",
+                                       env_name: "FASTLANE_RESET_SIMULATOR_VERSIONS",
+                                       description: "Which OS versions of Simulators you want to reset content and settings, this does not remove/recreate the simulators",
+                                       is_string: false,
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :os_versions,
+                                       short_option: "-v",
+                                       env_name: "FASTLANE_RESET_SIMULATOR_OS_VERSIONS",
+                                       description: "Which OS versions of Simulators you want to reset content and settings, this does not remove/recreate the simulators",
+                                       is_string: false,
+                                       optional: true,
+                                       type: Array)
+        ]
+      end
+
+      def self.aliases
+        ["reset_simulators"]
+      end
+
+      def self.output
+        nil
+      end
+
+      def self.return_value
+        nil
+      end
+
+      def self.authors
+        ["danramteke"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :tvos, :watchos].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'reset_simulator_contents',
+          'reset_simulator_contents(os_versions: ["10.3.1","12.2"])'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/resign.rb

@@ -0,0 +1,132 @@
+module Fastlane
+  module Actions
+    # Resigns the ipa
+    class ResignAction < Action
+      def self.run(params)
+        require 'sigh'
+
+        # try to resign the ipa
+        if Sigh::Resign.resign(params[:ipa], params[:signing_identity], params[:provisioning_profile], params[:entitlements], params[:version], params[:display_name], params[:short_version], params[:bundle_version], params[:bundle_id], params[:use_app_entitlements], params[:keychain_path])
+          UI.success('Successfully re-signed .ipa 🔏.')
+        else
+          UI.user_error!("Failed to re-sign .ipa")
+        end
+      end
+
+      def self.description
+        "Codesign an existing ipa file"
+      end
+
+      def self.example_code
+        [
+          'resign(
+            ipa: "path/to/ipa", # can omit if using the `ipa` action
+            signing_identity: "iPhone Distribution: Luka Mirosevic (0123456789)",
+            provisioning_profile: "path/to/profile", # can omit if using the _sigh_ action
+          )',
+          '# You may provide multiple provisioning profiles if the application contains nested
+          # applications or app extensions, which need their own provisioning profile.
+          # You can do so by passing an array of provisioning profile strings or a hash
+          # that associates provisioning profile values to bundle identifier keys.
+          resign(
+            ipa: "path/to/ipa", # can omit if using the `ipa` action
+            signing_identity: "iPhone Distribution: Luka Mirosevic (0123456789)",
+            provisioning_profile: {
+              "com.example.awesome-app" => "path/to/profile",
+              "com.example.awesome-app.app-extension" => "path/to/app-extension/profile"
+            }
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "FL_RESIGN_IPA",
+                                       description: "Path to the ipa file to resign. Optional if you use the _gym_ or _xcodebuild_ action",
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :signing_identity,
+                                       env_name: "FL_RESIGN_SIGNING_IDENTITY",
+                                       description: "Code signing identity to use. e.g. `iPhone Distribution: Luka Mirosevic (0123456789)`"),
+          FastlaneCore::ConfigItem.new(key: :entitlements,
+                                       env_name: "FL_RESIGN_ENTITLEMENTS",
+                                       description: "Path to the entitlement file to use, e.g. `myApp/MyApp.entitlements`",
+                                       conflicting_options: [:use_app_entitlements],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :provisioning_profile,
+                                       env_name: "FL_RESIGN_PROVISIONING_PROFILE",
+                                       description: "Path to your provisioning_profile. Optional if you use _sigh_",
+                                       default_value: Actions.lane_context[SharedValues::SIGH_PROFILE_PATH],
+                                       default_value_dynamic: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         files = case value
+                                                 when Hash then value.values
+                                                 when Enumerable then value
+                                                 else [value]
+                                                 end
+                                         files.each do |file|
+                                           UI.user_error!("Couldn't find provisioning profile at path '#{file}'") unless File.exist?(file)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "FL_RESIGN_VERSION",
+                                       description: "Version number to force resigned ipa to use. Updates both `CFBundleShortVersionString` and `CFBundleVersion` values in `Info.plist`. Applies for main app and all nested apps or extensions",
+                                       conflicting_options: [:short_version, :bundle_version],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :display_name,
+                                       env_name: "FL_DISPLAY_NAME",
+                                       description: "Display name to force resigned ipa to use",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :short_version,
+                                       env_name: "FL_RESIGN_SHORT_VERSION",
+                                       description: "Short version string to force resigned ipa to use (`CFBundleShortVersionString`)",
+                                       conflicting_options: [:version],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_version,
+                                       env_name: "FL_RESIGN_BUNDLE_VERSION",
+                                       description: "Bundle version to force resigned ipa to use (`CFBundleVersion`)",
+                                       conflicting_options: [:version],
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_id,
+                                       env_name: "FL_RESIGN_BUNDLE_ID",
+                                       description: "Set new bundle ID during resign (`CFBundleIdentifier`)",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_app_entitlements,
+                                       env_name: "FL_USE_APP_ENTITLEMENTS",
+                                       description: "Extract app bundle codesigning entitlements and combine with entitlements from new provisioning profile",
+                                       conflicting_options: [:entitlements],
+                                       is_string: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :keychain_path,
+                                       env_name: "FL_RESIGN_KEYCHAIN_PATH",
+                                       description: "Provide a path to a keychain file that should be used by `/usr/bin/codesign`",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end