fastlane 1.111.0 → 2.0.1

data/match/lib/match/nuke.rb

@@ -0,0 +1,190 @@
+module Match
+  class Nuke
+    attr_accessor :params
+    attr_accessor :type
+
+    attr_accessor :certs
+    attr_accessor :profiles
+    attr_accessor :files
+
+    def run(params, type: nil)
+      self.params = params
+      self.type = type
+
+      params[:workspace] = GitHelper.clone(params[:git_url], params[:shallow_clone], skip_docs: params[:skip_docs], branch: params[:git_branch])
+
+      had_app_identifier = self.params[:app_identifier]
+      self.params[:app_identifier] = '' # we don't really need a value here
+      FastlaneCore::PrintTable.print_values(config: params,
+                                         hide_keys: [:app_identifier, :workspace],
+                                             title: "Summary for match nuke #{Fastlane::VERSION}")
+
+      prepare_list
+      print_tables
+
+      if params[:readonly]
+        UI.user_error!("`match nuke` doesn't delete anything when running with --readonly enabled")
+      end
+
+      if (self.certs + self.profiles + self.files).count > 0
+        unless params[:skip_confirmation]
+          UI.error "---"
+          UI.error "Are you sure you want to completely delete and revoke all the"
+          UI.error "certificates and provisioning profiles listed above? (y/n)"
+          UI.error "Warning: By nuking distribution, both App Store and Ad Hoc profiles will be deleted" if type == "distribution"
+          UI.error "Warning: The :app_identifier value will be ignored - this will delete all profiles for all your apps!" if had_app_identifier
+          UI.error "---"
+        end
+        if params[:skip_confirmation] || agree("(y/n)", true)
+          nuke_it_now!
+          UI.success "Successfully cleaned your account ♻️"
+        else
+          UI.success "Cancelled nuking #thanks 🏠 👨 ‍👩 ‍👧"
+        end
+      else
+        UI.success "No relevant certificates or provisioning profiles found, nothing to nuke here :)"
+      end
+    end
+
+    # Collect all the certs/profiles
+    def prepare_list
+      UI.message "Fetching certificates and profiles..."
+      cert_type = Match.cert_type_sym(type)
+
+      prov_types = [:development]
+      prov_types = [:appstore, :adhoc] if cert_type == :distribution
+
+      Spaceship.login(params[:username])
+      Spaceship.select_team
+
+      self.certs = certificate_type(cert_type).all
+      self.profiles = []
+      prov_types.each do |prov_type|
+        self.profiles += profile_type(prov_type).all
+      end
+
+      certs = Dir[File.join(params[:workspace], "**", cert_type.to_s, "*.cer")]
+      keys = Dir[File.join(params[:workspace], "**", cert_type.to_s, "*.p12")]
+      profiles = []
+      prov_types.each do |prov_type|
+        profiles += Dir[File.join(params[:workspace], "**", prov_type.to_s, "*.mobileprovision")]
+      end
+
+      self.files = certs + keys + profiles
+    end
+
+    # Print tables to ask the user
+    def print_tables
+      puts ""
+      if self.certs.count > 0
+        puts Terminal::Table.new({
+          title: "Certificates that are going to be revoked".green,
+          headings: ["Name", "ID", "Type", "Expires"],
+          rows: self.certs.collect { |c| [c.name, c.id, c.class.to_s.split("::").last, c.expires.strftime("%Y-%m-%d")] }
+        })
+        puts ""
+      end
+
+      if self.profiles.count > 0
+        puts Terminal::Table.new({
+          title: "Provisioning Profiles that are going to be revoked".green,
+          headings: ["Name", "ID", "Status", "Type", "Expires"],
+          rows: self.profiles.collect do |p|
+            status = p.status == 'Active' ? p.status.green : p.status.red
+
+            [p.name, p.id, status, p.type, p.expires.strftime("%Y-%m-%d")]
+          end
+        })
+        puts ""
+      end
+
+      if self.files.count > 0
+        puts Terminal::Table.new({
+          title: "Files that are going to be deleted".green,
+          headings: ["Type", "File Name"],
+          rows: self.files.collect do |f|
+            components = f.split(File::SEPARATOR)[-3..-1]
+
+            # from "...1o7xtmh/certs/distribution/8K38XUY3AY.cer" to "distribution cert"
+            file_type = components[0..1].reverse.join(" ")[0..-2]
+
+            [file_type, components[2]]
+          end
+        })
+        puts ""
+      end
+    end
+
+    def nuke_it_now!
+      UI.header "Deleting #{self.profiles.count} provisioning profiles..." unless self.profiles.count == 0
+      self.profiles.each do |profile|
+        UI.message "Deleting profile '#{profile.name}' (#{profile.id})..."
+        begin
+          profile.delete!
+        rescue => ex
+          UI.message(ex.to_s)
+        end
+        UI.success "Successfully deleted profile"
+      end
+
+      UI.header "Revoking #{self.certs.count} certificates..." unless self.certs.count == 0
+      self.certs.each do |cert|
+        UI.message "Revoking certificate '#{cert.name}' (#{cert.id})..."
+        begin
+          cert.revoke!
+        rescue => ex
+          UI.message(ex.to_s)
+        end
+        UI.success "Successfully deleted certificate"
+      end
+
+      if self.files.count > 0
+        delete_files!
+      end
+
+      # Now we need to commit and push all this too
+      message = ["[fastlane]", "Nuked", "files", "for", type.to_s].join(" ")
+      GitHelper.commit_changes(params[:workspace], message, self.params[:git_url], params[:git_branch])
+    end
+
+    private
+
+    def delete_files!
+      UI.header "Deleting #{self.files.count} files from the git repo..."
+
+      self.files.each do |file|
+        UI.message "Deleting file '#{File.basename(file)}'..."
+
+        # Check if the profile is installed on the local machine
+        if file.end_with?("mobileprovision")
+          parsed = FastlaneCore::ProvisioningProfile.parse(file)
+          uuid = parsed["UUID"]
+          path = Dir[File.join(FastlaneCore::ProvisioningProfile.profiles_path, "#{uuid}.mobileprovision")].last
+          File.delete(path) if path
+        end
+
+        File.delete(file)
+        UI.success "Successfully deleted file"
+      end
+    end
+
+    # The kind of certificate we're interested in
+    def certificate_type(type)
+      cert_type = Spaceship.certificate.production
+      cert_type = Spaceship.certificate.development if type == :development
+      cert_type = Spaceship.certificate.in_house if Match.enterprise? && Spaceship.client.in_house?
+
+      cert_type
+    end
+
+    # The kind of provisioning profile we're interested in
+    def profile_type(type)
+      profile_type = Spaceship.provisioning_profile.app_store
+      profile_type = Spaceship.provisioning_profile.in_house if Match.enterprise? && Spaceship.client.in_house?
+      profile_type = Spaceship.provisioning_profile.ad_hoc if type == :adhoc
+      profile_type = Spaceship.provisioning_profile.development if type == :development
+
+      profile_type
+    end
+  end
+end

data/match/lib/match/options.rb

@@ -0,0 +1,124 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Match
+  class Options
+    def self.available_options
+      user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+      user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+
+      [
+        FastlaneCore::ConfigItem.new(key: :git_url,
+                                     env_name: "MATCH_GIT_URL",
+                                     description: "URL to the git repo containing all the certificates",
+                                     optional: false,
+                                     short_option: "-r"),
+        FastlaneCore::ConfigItem.new(key: :git_branch,
+                                     env_name: "MATCH_GIT_BRANCH",
+                                     description: "Specific git branch to use",
+                                     default_value: 'master'),
+        FastlaneCore::ConfigItem.new(key: :type,
+                                     env_name: "MATCH_TYPE",
+                                     description: "Create a development certificate instead of a distribution one",
+                                     is_string: true,
+                                     short_option: "-y",
+                                     default_value: 'development',
+                                     verify_block: proc do |value|
+                                       unless Match.environments.include?(value)
+                                         UI.user_error!("Unsupported environment #{value}, must be in #{Match.environments.join(', ')}")
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     short_option: "-a",
+                                     env_name: "MATCH_APP_IDENTIFIER",
+                                     description: "The bundle identifier(s) of your app (comma-separated)",
+                                     is_string: false,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)),
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     short_option: "-u",
+                                     env_name: "MATCH_USERNAME",
+                                     description: "Your Apple ID Username",
+                                     default_value: user),
+        FastlaneCore::ConfigItem.new(key: :keychain_name,
+                                     short_option: "-s",
+                                     env_name: "MATCH_KEYCHAIN_NAME",
+                                     description: "Keychain the items should be imported to",
+                                     default_value: "login.keychain"),
+        FastlaneCore::ConfigItem.new(key: :keychain_password,
+                                     short_option: "-p",
+                                     env_name: "MATCH_KEYCHAIN_PASSWORD",
+                                     sensitive: true,
+                                     description: "This might be required the first time you access certificates on a new mac. For the login/default keychain this is your account password",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :readonly,
+                                     env_name: "MATCH_READONLY",
+                                     description: "Only fetch existing certificates and profiles, don't generate new ones",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :team_id,
+                                     short_option: "-b",
+                                     env_name: "FASTLANE_TEAM_ID",
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :team_name,
+                                     short_option: "-l",
+                                     env_name: "FASTLANE_TEAM_NAME",
+                                     description: "The name of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :verbose,
+                                     env_name: "MATCH_VERBOSE",
+                                     description: "Print out extra information and all commands",
+                                     is_string: false,
+                                     default_value: false,
+                                     verify_block: proc do |value|
+                                       $verbose = true if value
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :force,
+                                     env_name: "MATCH_FORCE",
+                                     description: "Renew the provisioning profiles every time you run match",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_confirmation,
+                                     env_name: "MATCH_SKIP_CONFIRMATION",
+                                     description: "Disables confirmation prompts during nuke, answering them with yes",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :shallow_clone,
+                                     env_name: "MATCH_SHALLOW_CLONE",
+                                     description: "Make a shallow clone of the repository (truncate the history to 1 revision)",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     description: nil,
+                                     verify_block: proc do |value|
+                                       unless Helper.test?
+                                         if value.start_with?("/var/folders") or value.include?("tmp/") or value.include?("temp/")
+                                           # that's fine
+                                         else
+                                           UI.user_error!("Specify the `git_url` instead of the `path`")
+                                         end
+                                       end
+                                     end,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :force_for_new_devices,
+                                     env_name: "MATCH_FORCE_FOR_NEW_DEVICES",
+                                     description: "Renew the provisioning profiles if the device count on the developer portal has changed",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_docs,
+                                     env_name: "MATCH_SKIP_DOCS",
+                                     description: "Skip generation of a README.md for the created git repository",
+                                     is_string: false,
+                                     default_value: false)
+      ]
+    end
+  end
+end

data/match/lib/match/runner.rb

@@ -0,0 +1,172 @@
+module Match
+  class Runner
+    attr_accessor :changes_to_commit
+    attr_accessor :spaceship
+
+    def run(params)
+      FastlaneCore::PrintTable.print_values(config: params,
+                                         hide_keys: [:workspace],
+                                             title: "Summary for match #{Fastlane::VERSION}")
+
+      UI.error("Enterprise profiles are currently not officially supported in _match_, you might run into issues") if Match.enterprise?
+
+      params[:workspace] = GitHelper.clone(params[:git_url], params[:shallow_clone], skip_docs: params[:skip_docs], branch: params[:git_branch])
+      self.spaceship = SpaceshipEnsure.new(params[:username]) unless params[:readonly]
+
+      if params[:app_identifier].kind_of?(Array)
+        app_identifiers = params[:app_identifier]
+      else
+        app_identifiers = params[:app_identifier].to_s.split(/\s*,\s*/).uniq
+      end
+
+      # Verify the App ID (as we don't want 'match' to fail at a later point)
+      if spaceship
+        app_identifiers.each do |app_identifier|
+          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier)
+        end
+      end
+
+      # Certificate
+      cert_id = fetch_certificate(params: params)
+      spaceship.certificate_exists(username: params[:username], certificate_id: cert_id) if spaceship
+
+      # Provisioning Profiles
+      app_identifiers.each do |app_identifier|
+        loop do
+          break if fetch_provisioning_profile(params: params,
+                                      certificate_id: cert_id,
+                                      app_identifier: app_identifier)
+        end
+      end
+
+      # Done
+      if self.changes_to_commit and !params[:readonly]
+        message = GitHelper.generate_commit_message(params)
+        GitHelper.commit_changes(params[:workspace], message, params[:git_url], params[:git_branch])
+      end
+
+      # Print a summary table for each app_identifier
+      app_identifiers.each do |app_identifier|
+        TablePrinter.print_summary(app_identifier: app_identifier, type: params[:type])
+      end
+
+      UI.success "All required keys, certificates and provisioning profiles are installed 🙌".green
+    rescue Spaceship::Client::UnexpectedResponse, Spaceship::Client::InvalidUserCredentialsError, Spaceship::Client::NoUserCredentialsError => ex
+      UI.error("An error occured while verifying your certificates and profiles with the Apple Developer Portal.")
+      UI.error("If you already have your certificates stored in git, you can run `match` in readonly mode")
+      UI.error("to just install the certificates and profiles without accessing the Dev Portal.")
+      UI.error("To do so, just pass `readonly: true` to your match call.")
+      raise ex
+    ensure
+      GitHelper.clear_changes
+    end
+
+    def fetch_certificate(params: nil)
+      cert_type = Match.cert_type_sym(params[:type])
+
+      certs = Dir[File.join(params[:workspace], "certs", cert_type.to_s, "*.cer")]
+      keys = Dir[File.join(params[:workspace], "certs", cert_type.to_s, "*.p12")]
+
+      if certs.count == 0 or keys.count == 0
+        UI.important "Couldn't find a valid code signing identity in the git repo for #{cert_type}... creating one for you now"
+        UI.crash!("No code signing identity found and can not create a new one because you enabled `readonly`") if params[:readonly]
+        cert_path = Generator.generate_certificate(params, cert_type)
+        self.changes_to_commit = true
+      else
+        cert_path = certs.last
+        UI.message "Installing certificate..."
+
+        if FastlaneCore::CertChecker.installed?(cert_path)
+          UI.verbose "Certificate '#{File.basename(cert_path)}' is already installed on this machine"
+        else
+          Utils.import(cert_path, params[:keychain_name], password: params[:keychain_password])
+        end
+
+        # Import the private key
+        # there seems to be no good way to check if it's already installed - so just install it
+        Utils.import(keys.last, params[:keychain_name], password: params[:keychain_password])
+
+        # Get and print info of certificate
+        info = Utils.get_cert_info(cert_path)
+        TablePrinter.print_certificate_info(cert_info: info)
+      end
+
+      return File.basename(cert_path).gsub(".cer", "") # Certificate ID
+    end
+
+    # @return [String] The UUID of the provisioning profile so we can verify it with the Apple Developer Portal
+    def fetch_provisioning_profile(params: nil, certificate_id: nil, app_identifier: nil)
+      prov_type = Match.profile_type_sym(params[:type])
+
+      profile_name = [Match::Generator.profile_type_name(prov_type), app_identifier].join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
+      base_dir = File.join(params[:workspace], "profiles", prov_type.to_s)
+      profiles = Dir[File.join(base_dir, "#{profile_name}.mobileprovision")]
+
+      # Install the provisioning profiles
+      profile = profiles.last
+
+      if params[:force_for_new_devices] && !params[:readonly]
+        params[:force] = device_count_different?(profile: profile) unless params[:force]
+      end
+
+      if profile.nil? or params[:force]
+        if params[:readonly]
+          all_profiles = Dir.entries(base_dir).reject { |f| f.start_with? "." }
+          UI.error "No matching provisioning profiles found for '#{profile_name}'"
+          UI.error "A new one cannot be created because you enabled `readonly`"
+          UI.error "Provisioning profiles in your repo for type `#{prov_type}`:"
+          all_profiles.each { |p| UI.error "- '#{p}'" }
+          UI.error "If you are certain that a profile should exist, double-check the recent changes to your match repository"
+          UI.user_error! "No matching provisioning profiles found and can not create a new one because you enabled `readonly`. Check the output above for more information."
+        end
+        profile = Generator.generate_provisioning_profile(params: params,
+                                                       prov_type: prov_type,
+                                                  certificate_id: certificate_id,
+                                                  app_identifier: app_identifier)
+        self.changes_to_commit = true
+      end
+
+      FastlaneCore::ProvisioningProfile.install(profile)
+
+      parsed = FastlaneCore::ProvisioningProfile.parse(profile)
+      uuid = parsed["UUID"]
+
+      if spaceship && !spaceship.profile_exists(username: params[:username], uuid: uuid)
+        # This profile is invalid, let's remove the local file and generate a new one
+        File.delete(profile)
+        self.changes_to_commit = true
+        return nil
+      end
+
+      Utils.fill_environment(Utils.environment_variable_name(app_identifier: app_identifier,
+                                                                       type: prov_type),
+                             uuid)
+
+      # TeamIdentifier is returned as an array, but we're not sure why there could be more than one
+      Utils.fill_environment(Utils.environment_variable_name_team_id(app_identifier: app_identifier,
+                                                                               type: prov_type),
+                             parsed["TeamIdentifier"].first)
+
+      Utils.fill_environment(Utils.environment_variable_name_profile_name(app_identifier: app_identifier,
+                                                                                    type: prov_type),
+                             parsed["Name"])
+
+      return uuid
+    end
+
+    def device_count_different?(profile: nil)
+      if profile
+        parsed = FastlaneCore::ProvisioningProfile.parse(profile)
+        uuid = parsed["UUID"]
+        portal_profile = Spaceship.provisioning_profile.all.detect { |i| i.uuid == uuid }
+
+        if portal_profile
+          profile_device_count = portal_profile.devices.count
+          portal_device_count = Spaceship.device.all.count
+          return portal_device_count != profile_device_count
+        end
+      end
+      return false
+    end
+  end
+end