fastlane_iac_publish 0.1.0

data/match/lib/match/setup.rb

@@ -0,0 +1,40 @@
+require_relative 'module'
+require_relative 'storage'
+
+module Match
+  class Setup
+    def run(path, is_swift_fastfile: false)
+      if is_swift_fastfile
+        template = File.read("#{Match::ROOT}/lib/assets/MatchfileTemplate.swift")
+      else
+        template = File.read("#{Match::ROOT}/lib/assets/MatchfileTemplate")
+      end
+
+      storage_mode = UI.select(
+        "fastlane match supports multiple storage modes, please select the one you want to use:",
+        self.storage_options
+      )
+
+      storage = Storage.for_mode(storage_mode, {})
+
+      specific_content = storage.generate_matchfile_content
+      UI.crash!("Looks like `generate_matchfile_content` was `nil` for `#{storage_mode}`") if specific_content.nil?
+      specific_content += "\n\n" if specific_content.length > 0
+      specific_content += "storage_mode(\"#{storage_mode}\")"
+
+      template.gsub!("[[CONTENT]]", specific_content)
+
+      File.write(path, template)
+      UI.success("Successfully created '#{path}'. You can open the file using a code editor.")
+
+      UI.important("You can now run `fastlane match development`, `fastlane match adhoc`, `fastlane match enterprise` and `fastlane match appstore`")
+      UI.message("On the first run for each environment it will create the provisioning profiles and")
+      UI.message("certificates for you. From then on, it will automatically import the existing profiles.")
+      UI.message("For more information visit https://docs.fastlane.tools/actions/match/")
+    end
+
+    def storage_options
+      return ["git", "google_cloud"]
+    end
+  end
+end

data/match/lib/match/spaceship_ensure.rb

@@ -0,0 +1,83 @@
+require 'spaceship'
+require_relative 'module'
+
+module Match
+  # Ensures the certificate and profiles are also available on App Store Connect
+  class SpaceshipEnsure
+    def initialize(user, team_id, team_name)
+      # We'll try to manually fetch the password
+      # to tell the user that a password is optional
+      require 'credentials_manager/account_manager'
+
+      keychain_entry = CredentialsManager::AccountManager.new(user: user)
+
+      if keychain_entry.password(ask_if_missing: false).to_s.length == 0
+        UI.important("You can also run `fastlane match` in readonly mode to not require any access to the")
+        UI.important("Developer Portal. This way you only share the keys and credentials")
+        UI.command("fastlane match --readonly")
+        UI.important("More information https://docs.fastlane.tools/actions/match/#access-control")
+      end
+
+      UI.message("Verifying that the certificate and profile are still valid on the Dev Portal...")
+      Spaceship.login(user)
+      Spaceship.select_team(team_id: team_id, team_name: team_name)
+    end
+
+    # The team ID of the currently logged in team
+    def team_id
+      return Spaceship.client.team_id
+    end
+
+    def bundle_identifier_exists(username: nil, app_identifier: nil)
+      found = Spaceship.app.find(app_identifier)
+      return if found
+
+      require 'sigh/runner'
+      Sigh::Runner.new.print_produce_command({
+        username: username,
+        app_identifier: app_identifier
+      })
+      UI.error("An app with that bundle ID needs to exist in order to create a provisioning profile for it")
+      UI.error("================================================================")
+      available_apps = Spaceship.app.all.collect { |a| "#{a.bundle_id} (#{a.name})" }
+      UI.message("Available apps:\n- #{available_apps.join("\n- ")}")
+      UI.error("Make sure to run `fastlane match` with the same user and team every time.")
+      UI.user_error!("Couldn't find bundle identifier '#{app_identifier}' for the user '#{username}'")
+    end
+
+    def certificate_exists(username: nil, certificate_id: nil)
+      found = Spaceship.certificate.all.find do |cert|
+        cert.id == certificate_id
+      end
+      return if found
+
+      UI.error("Certificate '#{certificate_id}' (stored in your storage) is not available on the Developer Portal")
+      UI.error("for the user #{username}")
+      UI.error("Make sure to use the same user and team every time you run 'match' for this")
+      UI.error("Git repository. This might be caused by revoking the certificate on the Dev Portal")
+      UI.user_error!("To reset the certificates of your Apple account, you can use the `fastlane match nuke` feature, more information on https://docs.fastlane.tools/actions/match/")
+    end
+
+    def profile_exists(username: nil, uuid: nil)
+      found = Spaceship.provisioning_profile.all.find do |profile|
+        profile.uuid == uuid
+      end
+
+      unless found
+        UI.error("Provisioning profile '#{uuid}' is not available on the Developer Portal for the user #{username}, fixing this now for you 🔨")
+        return false
+      end
+
+      if found.valid?
+        return found
+      else
+        UI.important("'#{found.name}' is available on the Developer Portal, however it's 'Invalid', fixing this now for you 🔨")
+        # it's easier to just create a new one, than to repair an existing profile
+        # it has the same effects anyway, including a new UUID of the provisioning profile
+        found.delete!
+        # return nil to re-download the new profile in runner.rb
+        return nil
+      end
+    end
+  end
+end

data/match/lib/match/storage.rb

@@ -0,0 +1,42 @@
+require_relative 'storage/interface'
+require_relative 'storage/git_storage'
+require_relative 'storage/google_cloud_storage'
+
+module Match
+  module Storage
+    class << self
+      def backends
+        @backends ||= {
+          "git" => lambda { |params|
+            return Storage::GitStorage.configure(params)
+          },
+          "google_cloud" => lambda { |params|
+            return Storage::GoogleCloudStorage.configure(params)
+          }
+        }
+      end
+
+      def register_backend(type: nil, storage_class: nil, &configurator)
+        UI.user_error!("No type specified for storage backend") if type.nil?
+
+        normalized_name = type.to_s
+        UI.message("Replacing Match::Encryption backend for type '#{normalized_name}'") if backends.include?(normalized_name)
+
+        if configurator
+          @backends[normalized_name] = configurator
+        elsif storage_class
+          @backends[normalized_name] = ->(params) { return storage_class.configure(params) }
+        else
+          UI.user_error!("Specify either a `storage_class` or a configuration block when registering a storage backend")
+        end
+      end
+
+      def for_mode(storage_mode, params)
+        configurator = backends[storage_mode.to_s]
+        return configurator.call(params) if configurator
+
+        UI.user_error!("No storage backend for storage mode '#{storage_mode}'")
+      end
+    end
+  end
+end

data/match/lib/match/storage/git_storage.rb

@@ -0,0 +1,214 @@
+require 'fastlane_core/command_executor'
+
+require_relative '../module'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities in a git repo
+    class GitStorage < Interface
+      # User provided values
+      attr_accessor :git_url
+      attr_accessor :shallow_clone
+      attr_accessor :skip_docs
+      attr_accessor :branch
+      attr_accessor :git_full_name
+      attr_accessor :git_user_email
+      attr_accessor :clone_branch_directly
+      attr_accessor :type
+      attr_accessor :platform
+
+      def self.configure(params)
+        return self.new(
+          type: params[:type].to_s,
+          platform: params[:platform].to_s,
+          git_url: params[:git_url],
+          shallow_clone: params[:shallow_clone],
+          skip_docs: params[:skip_docs],
+          branch: params[:git_branch],
+          git_full_name: params[:git_full_name],
+          git_user_email: params[:git_user_email],
+          clone_branch_directly: params[:clone_branch_directly]
+        )
+      end
+
+      def initialize(type: nil,
+                     platform: nil,
+                     git_url: nil,
+                     shallow_clone: nil,
+                     skip_docs: false,
+                     branch: "master",
+                     git_full_name: nil,
+                     git_user_email: nil,
+                     clone_branch_directly: false)
+        self.git_url = git_url
+        self.shallow_clone = shallow_clone
+        self.skip_docs = skip_docs
+        self.branch = branch
+        self.git_full_name = git_full_name
+        self.git_user_email = git_user_email
+        self.clone_branch_directly = clone_branch_directly
+
+        self.type = type if type
+        self.platform = platform if platform
+      end
+
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        command = "git clone #{self.git_url.shellescape} #{self.working_directory.shellescape}"
+        if self.shallow_clone
+          command << " --depth 1 --no-single-branch"
+        elsif self.clone_branch_directly
+          command += " -b #{self.branch.shellescape} --single-branch"
+        end
+
+        UI.message("Cloning remote git repo...")
+        if self.branch && !self.clone_branch_directly
+          UI.message("If cloning the repo takes too long, you can use the `clone_branch_directly` option in match.")
+        end
+
+        begin
+          # GIT_TERMINAL_PROMPT will fail the `git clone` command if user credentials are missing
+          Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                            print_command: FastlaneCore::Globals.verbose?)
+          end
+        rescue
+          UI.error("Error cloning certificates repo, please make sure you have read access to the repository you want to use")
+          if self.branch && self.clone_branch_directly
+            UI.error("You passed '#{self.branch}' as branch in combination with the `clone_branch_directly` flag. Please remove `clone_branch_directly` flag on the first run for _match_ to create the branch.")
+          end
+          UI.error("Run the following command manually to make sure you're properly authenticated:")
+          UI.command(command)
+          UI.user_error!("Error cloning certificates git repo, please make sure you have access to the repository - see instructions above")
+        end
+
+        add_user_config(self.git_full_name, self.git_user_email)
+
+        unless File.directory?(self.working_directory)
+          UI.user_error!("Error cloning repo, make sure you have access to it '#{self.git_url}'")
+        end
+
+        checkout_branch unless self.branch == "master"
+      end
+
+      def human_readable_description
+        "Git Repo [#{self.git_url}]"
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        # No specific list given, e.g. this happens on `fastlane match nuke`
+        # We just want to run `git add -A` to commit everything
+        git_push(commands: ["git add -A"], commit_message: custom_message)
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        commands = files_to_upload.map do |current_file|
+          "git add #{current_file.shellescape}"
+        end
+
+        git_push(commands: commands, commit_message: custom_message)
+      end
+
+      # Generate the commit message based on the user's parameters
+      def generate_commit_message
+        [
+          "[fastlane]",
+          "Updated",
+          self.type,
+          "and platform",
+          self.platform
+        ].join(" ")
+      end
+
+      def generate_matchfile_content
+        UI.important("Please create a new, private git repository to store the certificates and profiles there")
+        url = UI.input("URL of the Git Repo: ")
+
+        return "git_url(\"#{url}\")"
+      end
+
+      private
+
+      # Create and checkout an specific branch in the git repo
+      def checkout_branch
+        return unless self.working_directory
+
+        commands = []
+        if branch_exists?(self.branch)
+          # Checkout the branch if it already exists
+          commands << "git checkout #{self.branch.shellescape}"
+        else
+          # If a new branch is being created, we create it as an 'orphan' to not inherit changes from the master branch.
+          commands << "git checkout --orphan #{self.branch.shellescape}"
+          # We also need to reset the working directory to not transfer any uncommitted changes to the new branch.
+          commands << "git reset --hard"
+        end
+
+        UI.message("Checking out branch #{self.branch}...")
+
+        Dir.chdir(self.working_directory) do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                  print_all: FastlaneCore::Globals.verbose?,
+                                                  print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      end
+
+      # Checks if a specific branch exists in the git repo
+      def branch_exists?(branch)
+        return unless self.working_directory
+
+        result = Dir.chdir(self.working_directory) do
+          FastlaneCore::CommandExecutor.execute(command: "git --no-pager branch --list origin/#{branch.shellescape} --no-color -r",
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                                print_command: FastlaneCore::Globals.verbose?)
+        end
+        return !result.empty?
+      end
+
+      def add_user_config(user_name, user_email)
+        # Add git config if needed
+        commands = []
+        commands << "git config user.name \"#{user_name}\"" unless user_name.nil?
+        commands << "git config user.email \"#{user_email}\"" unless user_email.nil?
+
+        return if commands.empty?
+
+        UI.message("Add git user config to local git repo...")
+        Dir.chdir(self.working_directory) do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                  print_all: FastlaneCore::Globals.verbose?,
+                                                  print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      end
+
+      def git_push(commands: [], commit_message: nil)
+        commit_message ||= generate_commit_message
+        commands << "git commit -m #{commit_message.shellescape}"
+        commands << "git push origin #{self.branch.shellescape}"
+
+        UI.message("Pushing changes to remote git repo...")
+        Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+          commands.each do |command|
+            FastlaneCore::CommandExecutor.execute(command: command,
+                                                print_all: FastlaneCore::Globals.verbose?,
+                                            print_command: FastlaneCore::Globals.verbose?)
+          end
+        end
+      rescue => ex
+        UI.error("Couldn't commit or push changes back to git...")
+        UI.error(ex)
+      end
+    end
+  end
+end

data/match/lib/match/storage/google_cloud_storage.rb

@@ -0,0 +1,265 @@
+require 'fastlane_core/command_executor'
+require 'fastlane_core/configuration/configuration'
+require 'google/cloud/storage'
+
+require_relative '../options'
+require_relative '../module'
+require_relative './interface'
+
+module Match
+  module Storage
+    # Store the code signing identities in on Google Cloud Storage
+    class GoogleCloudStorage < Interface
+      DEFAULT_KEYS_FILE_NAME = "gc_keys.json"
+
+      # User provided values
+      attr_reader :type
+      attr_reader :platform
+      attr_reader :bucket_name
+      attr_reader :google_cloud_keys_file
+      attr_reader :google_cloud_project_id
+
+      # Managed values
+      attr_accessor :gc_storage
+
+      def self.configure(params)
+        if params[:git_url].to_s.length > 0
+          UI.important("Looks like you still define a `git_url` somewhere, even though")
+          UI.important("you use Google Cloud Storage. You can remove the `git_url`")
+          UI.important("from your Matchfile and Fastfile")
+          UI.message("The above is just a warning, fastlane will continue as usual now...")
+        end
+
+        return self.new(
+          type: params[:type].to_s,
+          platform: params[:platform].to_s,
+          google_cloud_bucket_name: params[:google_cloud_bucket_name],
+          google_cloud_keys_file: params[:google_cloud_keys_file],
+          google_cloud_project_id: params[:google_cloud_project_id]
+        )
+      end
+
+      def initialize(type: nil,
+                     platform: nil,
+                     google_cloud_bucket_name: nil,
+                     google_cloud_keys_file: nil,
+                     google_cloud_project_id: nil)
+        @type = type if type
+        @platform = platform if platform
+        @google_cloud_project_id = google_cloud_project_id if google_cloud_project_id
+        @bucket_name = google_cloud_bucket_name
+
+        @google_cloud_keys_file = ensure_keys_file_exists(google_cloud_keys_file, google_cloud_project_id)
+
+        if self.google_cloud_keys_file.to_s.length > 0
+          # Extract the Project ID from the `JSON` file
+          # so the user doesn't have to provide it manually
+          keys_file_content = JSON.parse(File.read(self.google_cloud_keys_file))
+          if google_cloud_project_id.to_s.length > 0 && google_cloud_project_id != keys_file_content["project_id"]
+            UI.important("The google_cloud_keys_file's project ID ('#{keys_file_content['project_id']}') doesn't match the google_cloud_project_id ('#{google_cloud_project_id}'). This may be the wrong keys file.")
+          end
+          @google_cloud_project_id = keys_file_content["project_id"]
+          if self.google_cloud_project_id.to_s.length == 0
+            UI.user_error!("Provided keys file on path #{File.expand_path(self.google_cloud_keys_file)} doesn't include required value for `project_id`")
+          end
+        end
+
+        # Create the Google Cloud Storage client
+        # If the JSON auth file is invalid, this line will
+        # raise an exception
+        begin
+          self.gc_storage = Google::Cloud::Storage.new(
+            credentials: self.google_cloud_keys_file,
+            project_id: self.google_cloud_project_id
+          )
+        rescue => ex
+          UI.error(ex)
+          UI.verbose(ex.backtrace.join("\n"))
+          UI.user_error!("Couldn't log into your Google Cloud account using the provided JSON file at path '#{File.expand_path(self.google_cloud_keys_file)}'")
+        end
+
+        ensure_bucket_is_selected
+      end
+
+      def download
+        # Check if we already have a functional working_directory
+        return if @working_directory
+
+        # No existing working directory, creating a new one now
+        self.working_directory = Dir.mktmpdir
+
+        bucket.files.each do |current_file|
+          file_path = current_file.name # e.g. "N8X438SEU2/certs/distribution/XD9G7QCACF.cer"
+          download_path = File.join(self.working_directory, file_path)
+
+          FileUtils.mkdir_p(File.expand_path("..", download_path))
+          UI.verbose("Downloading file from Google Cloud Storage '#{file_path}' on bucket #{self.bucket_name}")
+          current_file.download(download_path)
+        end
+        UI.verbose("Successfully downloaded files from GCS to #{self.working_directory}")
+      end
+
+      def delete_files(files_to_delete: [], custom_message: nil)
+        files_to_delete.each do |current_file|
+          target_path = current_file.gsub(self.working_directory + "/", "")
+          file = bucket.file(target_path)
+          UI.message("Deleting '#{target_path}' from Google Cloud Storage bucket '#{self.bucket_name}'...")
+          file.delete
+        end
+      end
+
+      def human_readable_description
+        "Google Cloud Bucket [#{self.google_cloud_project_id}/#{self.bucket_name}]"
+      end
+
+      def upload_files(files_to_upload: [], custom_message: nil)
+        # `files_to_upload` is an array of files that need to be uploaded to Google Cloud
+        # Those doesn't mean they're new, it might just be they're changed
+        # Either way, we'll upload them using the same technique
+
+        files_to_upload.each do |current_file|
+          # Go from
+          #   "/var/folders/px/bz2kts9n69g8crgv4jpjh6b40000gn/T/d20181026-96528-1av4gge/profiles/development/Development_me.mobileprovision"
+          # to
+          #   "profiles/development/Development_me.mobileprovision"
+          #
+
+          # We also have to remove the trailing `/` as Google Cloud doesn't handle it nicely
+          target_path = current_file.gsub(self.working_directory + "/", "")
+          UI.verbose("Uploading '#{target_path}' to Google Cloud Storage...")
+          bucket.create_file(current_file, target_path)
+        end
+      end
+
+      def skip_docs
+        false
+      end
+
+      def generate_matchfile_content
+        return "bucket_name(\"#{self.bucket_name}\")"
+      end
+
+      private
+
+      def bucket
+        @_bucket ||= self.gc_storage.bucket(self.bucket_name)
+
+        if @_bucket.nil?
+          UI.user_error!("Couldn't find Google Cloud Storage bucket with name #{self.bucket_name} for the currently used account. Please make sure you have access")
+        end
+
+        return @_bucket
+      end
+
+      ##########################
+      # Setup related methods
+      ##########################
+
+      # This method will make sure the keys file exists
+      # If it's missing, it will help the user set things up
+      def ensure_keys_file_exists(google_cloud_keys_file, google_cloud_project_id)
+        if google_cloud_keys_file && File.exist?(google_cloud_keys_file)
+          return google_cloud_keys_file
+        end
+
+        return DEFAULT_KEYS_FILE_NAME if File.exist?(DEFAULT_KEYS_FILE_NAME)
+
+        fastlane_folder_gc_keys_path = File.join(FastlaneCore::FastlaneFolder.path, DEFAULT_KEYS_FILE_NAME)
+        return fastlane_folder_gc_keys_path if File.exist?(fastlane_folder_gc_keys_path)
+
+        if google_cloud_project_id.to_s.length > 0
+          # Check to see if this system has application default keys installed.
+          # These are the default keys that the Google Cloud APIs use when no other keys are specified.
+          # Users with the Google Cloud SDK installed can generate them by running...
+          # `gcloud auth application-default login`
+          # ...and then they'll be automatically available.
+          # The nice thing about these keys is they can be associated with the user's login in GCP
+          # (e.g. my_account@gmail.com), so teams can control access to the certificate bucket
+          # using a mailing list of developer logins instead of generating service accounts
+          # and keys.
+          application_default_keys = nil
+          begin
+            application_default_keys = Google::Auth.get_application_default
+          rescue
+            # This means no application default keys have been installed. That's perfectly OK,
+            # we can continue and ask the user if they want to use a keys file.
+          end
+
+          if application_default_keys && UI.confirm("Do you want to use this system's Google Cloud application default keys?")
+            return nil
+          end
+        end
+
+        # User doesn't seem to have provided a keys file.
+        UI.message("Looks like you don't have a Google Cloud #{DEFAULT_KEYS_FILE_NAME.cyan} file")
+        UI.message("If you have one, make sure to put it into the '#{Dir.pwd}' directory and call it '#{DEFAULT_KEYS_FILE_NAME.cyan}'")
+        unless UI.confirm("Do you want fastlane to help you to create a #{DEFAULT_KEYS_FILE_NAME} file?")
+          UI.user_error!("Process stopped, run fastlane again to start things up again")
+        end
+
+        UI.message("fastlane will help you create a keys file. First, open the following website")
+        UI.message("")
+        UI.message("\t\thttps://console.cloud.google.com".cyan)
+        UI.message("")
+        UI.input("Press enter once you're logged in")
+
+        UI.message("Now it's time to generate a new JSON auth file for fastlane to access Google Cloud")
+        UI.message("First, switch to the Google Cloud project you want to use.")
+        UI.message("If you don't have one yet, create a new one and switch to it")
+        UI.message("")
+        UI.message("\t\thttps://console.cloud.google.com/apis/credentials".cyan)
+        UI.message("")
+        UI.input("Ensure the right project is selected on top of the page and confirm with enter")
+
+        UI.message("Now create a new JSON auth file by clicking on")
+        UI.message("")
+        UI.message("\t\t 1. Create credentials".cyan)
+        UI.message("\t\t 2. Service account key".cyan)
+        UI.message("\t\t 3. App Engine default service account".cyan)
+        UI.message("\t\t 4. JSON".cyan)
+        UI.message("\t\t 5. Create".cyan)
+        UI.message("")
+        UI.input("Confirm with enter once you created and download the JSON file")
+
+        UI.message("Copy the file to the current directory (#{Dir.pwd})")
+        UI.message("and rename it to `#{DEFAULT_KEYS_FILE_NAME.cyan}`")
+        UI.message("")
+        UI.input("Confirm with enter")
+
+        until File.exist?(DEFAULT_KEYS_FILE_NAME)
+          UI.message("Make sure to place the file in '#{Dir.pwd.cyan}' and name it '#{DEFAULT_KEYS_FILE_NAME.cyan}'")
+          UI.input("Confirm with enter")
+        end
+
+        UI.important("Please never add the #{DEFAULT_KEYS_FILE_NAME.cyan} file in version control.")
+        UI.important("Instead please add the file to your .gitignore")
+        UI.input("Confirm with enter")
+
+        return DEFAULT_KEYS_FILE_NAME
+      end
+
+      def ensure_bucket_is_selected
+        # In case the user didn't provide a bucket name yet, they will
+        # be asked to provide one here
+        while self.bucket_name.to_s.length == 0
+          # Have a nice selection of the available buckets here
+          # This can only happen after we went through auth of Google Cloud
+          available_bucket_identifiers = self.gc_storage.buckets.collect(&:id)
+          if available_bucket_identifiers.count > 0
+            @bucket_name = UI.select("What Google Cloud Storage bucket do you want to use? (you can define it using the `google_cloud_bucket_name` key)", available_bucket_identifiers)
+          else
+            UI.error("Looks like your Google Cloud account for the project ID '#{self.google_cloud_project_id}' doesn't")
+            UI.error("have any available storage buckets yet. Please visit the following URL")
+            UI.message("")
+            UI.message("\t\thttps://console.cloud.google.com/storage/browser".cyan)
+            UI.message("")
+            UI.message("and make sure to have the right project selected on top of the page")
+            UI.message("click on " + "Create Bucket".cyan + ", choose a name and confirm")
+            UI.message("")
+            UI.input("Once you're finished, please confirm with enter")
+          end
+        end
+      end
+    end
+  end
+end