fastlane 2.136.0 → 2.141.0

data/match/lib/match/module.rb

@@ -9,7 +9,7 @@ module Match
   DESCRIPTION = "Easily sync your certificates and profiles across your team"
 
   def self.environments
-    return %w(appstore adhoc development enterprise)
+    return %w(appstore adhoc development enterprise developer_id)
   end
 
   def self.storage_modes
@@ -21,6 +21,9 @@ module Match
   end
 
   def self.cert_type_sym(type)
+    return :mac_installer_distribution if type == "mac_installer_distribution"
+    return :developer_id_installer if type == "developer_id_installer"
+    return :developer_id_application if type == "developer_id"
     return :enterprise if type == "enterprise"
     return :development if type == "development"
     return :distribution if ["adhoc", "appstore", "distribution"].include?(type)

data/match/lib/match/nuke.rb

@@ -93,10 +93,11 @@ module Match
     def prepare_list
       UI.message("Fetching certificates and profiles...")
       cert_type = Match.cert_type_sym(type)
+      cert_types = [cert_type]
 
       prov_types = []
       prov_types = [:development] if cert_type == :development
-      prov_types = [:appstore, :adhoc] if cert_type == :distribution
+      prov_types = [:appstore, :adhoc, :developer_id] if cert_type == :distribution
       prov_types = [:enterprise] if cert_type == :enterprise
 
       Spaceship.login(params[:username])
@@ -112,17 +113,39 @@ module Match
         UI.user_error!("Enterprise account nuke cancelled") unless UI.confirm("Do you really want to nuke your Enterprise account?")
       end
 
-      self.certs = certificate_type(cert_type).flat_map(&:all)
+      # Get all iOS and macOS profile
       self.profiles = []
       prov_types.each do |prov_type|
-        self.profiles += profile_type(prov_type).all
+        self.profiles += profile_type(prov_type).all(mac: false)
+        self.profiles += profile_type(prov_type).all(mac: true)
       end
 
-      certs = Dir[File.join(self.storage.working_directory, "**", cert_type.to_s, "*.cer")]
-      keys = Dir[File.join(self.storage.working_directory, "**", cert_type.to_s, "*.p12")]
+      # Gets the main and additional cert types
+      cert_types += (params[:additional_cert_types] || []).map do |ct|
+        Match.cert_type_sym(ct)
+      end
+
+      # Gets all the certs form the cert types
+      self.certs = []
+      self.certs += cert_types.map do |ct|
+        certificate_type(ct).flat_map do |cert|
+          cert.all(mac: false) + cert.all(mac: true)
+        end
+      end.flatten
+
+      # Finds all the .cer and .p12 files in the file storage
+      certs = []
+      keys = []
+      cert_types.each do |ct|
+        certs += Dir[File.join(self.storage.working_directory, "**", ct.to_s, "*.cer")]
+        keys += Dir[File.join(self.storage.working_directory, "**", ct.to_s, "*.p12")]
+      end
+
+      # Finds all the iOS and macOS profofiles in the file storage
       profiles = []
       prov_types.each do |prov_type|
         profiles += Dir[File.join(self.storage.working_directory, "**", prov_type.to_s, "*.mobileprovision")]
+        profiles += Dir[File.join(self.storage.working_directory, "**", prov_type.to_s, "*.provisionprofile")]
       end
 
       self.files = certs + keys + profiles
@@ -240,21 +263,36 @@ module Match
 
     # The kind of certificate we're interested in
     def certificate_type(type)
-      {
-        distribution: [Spaceship.certificate.production, Spaceship.certificate.apple_distribution],
-        development:  [Spaceship.certificate.development, Spaceship.certificate.apple_development],
-        enterprise:   [Spaceship.certificate.in_house]
-      }[type] ||= raise "Unknown type '#{type}'"
+      case type.to_sym
+      when :mac_installer_distribution
+        return [Spaceship.certificate.mac_installer_distribution]
+      when :distribution
+        return [Spaceship.certificate.production, Spaceship.certificate.apple_distribution]
+      when :development
+        return [Spaceship.certificate.development, Spaceship.certificate.apple_development]
+      when :enterprise
+        return [Spaceship.certificate.in_house]
+      else
+        raise "Unknown type '#{type}'"
+      end
     end
 
     # The kind of provisioning profile we're interested in
     def profile_type(prov_type)
-      {
-        appstore:    Spaceship.provisioning_profile.app_store,
-        development: Spaceship.provisioning_profile.development,
-        enterprise:  Spaceship.provisioning_profile.in_house,
-        adhoc:       Spaceship.provisioning_profile.ad_hoc
-      }[prov_type] ||= raise "Unknown provisioning type '#{prov_type}'"
+      case prov_type.to_sym
+      when :appstore
+        return Spaceship.provisioning_profile.app_store
+      when :development
+        return Spaceship.provisioning_profile.development
+      when :enterprise
+        return Spaceship.provisioning_profile.in_house
+      when :adhoc
+        return Spaceship.provisioning_profile.ad_hoc
+      when :developer_id
+        return Spaceship.provisioning_profile.direct
+      else
+        raise "Unknown provisioning type '#{prov_type}'"
+      end
     end
   end
 end

data/match/lib/match/options.rb

@@ -19,7 +19,6 @@ module Match
         FastlaneCore::ConfigItem.new(key: :type,
                                      env_name: "MATCH_TYPE",
                                      description: "Define the profile type, can be #{Match.environments.join(', ')}",
-                                     is_string: true,
                                      short_option: "-y",
                                      default_value: 'development',
                                      verify_block: proc do |value|
@@ -27,10 +26,19 @@ module Match
                                          UI.user_error!("Unsupported environment #{value}, must be in #{Match.environments.join(', ')}")
                                        end
                                      end),
+        FastlaneCore::ConfigItem.new(key: :additional_cert_types,
+                                     env_name: "MATCH_ADDITIONAL_CERT_TYPES",
+                                     description: "Create additional cert types needed for macOS installers (valid values: mac_installer_distribution, developer_id_installer)",
+                                     optional: true,
+                                     type: Array,
+                                     verify_block: proc do |values|
+                                       types = %w(mac_installer_distribution developer_id_installer)
+                                       UI.user_error!("Unsupported types, must be: #{types}") unless (values - types).empty?
+                                     end),
         FastlaneCore::ConfigItem.new(key: :readonly,
                                      env_name: "MATCH_READONLY",
                                      description: "Only fetch existing certificates and profiles, don't generate new ones",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :generate_apple_certs,
                                      env_name: "MATCH_GENERATE_APPLE_CERTS",
@@ -41,7 +49,7 @@ module Match
         FastlaneCore::ConfigItem.new(key: :skip_provisioning_profiles,
                                      env_name: "MATCH_SKIP_PROVISIONING_PROFILES",
                                      description: "Skip syncing provisioning profiles",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
 
         # app
@@ -49,7 +57,6 @@ module Match
                                      short_option: "-a",
                                      env_name: "MATCH_APP_IDENTIFIER",
                                      description: "The bundle identifier(s) of your app (comma-separated)",
-                                     is_string: false,
                                      type: Array, # we actually allow String and Array here
                                      skip_type_validation: true,
                                      code_gen_sensitive: true,
@@ -82,7 +89,6 @@ module Match
         FastlaneCore::ConfigItem.new(key: :storage_mode,
                                      env_name: "MATCH_STORAGE_MODE",
                                      description: "Define where you want to store your certificates",
-                                     is_string: true,
                                      short_option: "-q",
                                      default_value: 'git',
                                      verify_block: proc do |value|
@@ -114,17 +120,25 @@ module Match
         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,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :clone_branch_directly,
                                      env_name: "MATCH_CLONE_BRANCH_DIRECTLY",
                                      description: "Clone just the branch specified, instead of the whole repo. This requires that the branch already exists. Otherwise the command will fail",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :git_basic_authorization,
                                      env_name: "MATCH_GIT_BASIC_AUTHORIZATION",
                                      sensitive: true,
                                      description: "Use a basic authorization header to access the git repo (e.g.: access via HTTPS, GitHub Actions, etc), usually a string in Base64",
+                                     conflicting_options: [:git_bearer_authorization],
+                                     optional: true,
+                                     default_value: nil),
+        FastlaneCore::ConfigItem.new(key: :git_bearer_authorization,
+                                     env_name: "MATCH_GIT_BEARER_AUTHORIZATION",
+                                     sensitive: true,
+                                     description: "Use a bearer authorization header to access the git repo (e.g.: access to an Azure Devops repository), usually a string in Base64",
+                                     conflicting_options: [:git_basic_authorization],
                                      optional: true,
                                      default_value: nil),
 
@@ -162,32 +176,31 @@ module Match
         FastlaneCore::ConfigItem.new(key: :force,
                                      env_name: "MATCH_FORCE",
                                      description: "Renew the provisioning profiles every time you run match",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false),
         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. Ignored for profile type 'appstore'",
-                                     is_string: false,
+                                     type: Boolean,
                                      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,
+                                     type: Boolean,
                                      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,
+                                     type: Boolean,
                                      default_value: false),
         FastlaneCore::ConfigItem.new(key: :platform,
                                      short_option: '-o',
                                      env_name: "MATCH_PLATFORM",
-                                     description: "Set the provisioning profile's platform to work with (i.e. ios, tvos)",
-                                     is_string: false,
+                                     description: "Set the provisioning profile's platform to work with (i.e. ios, tvos, macos)",
                                      default_value: "ios",
                                      verify_block: proc do |value|
                                        value = value.to_s
-                                       pt = %w(tvos ios)
+                                       pt = %w(tvos ios macos)
                                        UI.user_error!("Unsupported platform, must be: #{pt}") unless pt.include?(value)
                                      end),
         FastlaneCore::ConfigItem.new(key: :template_name,
@@ -204,7 +217,7 @@ module Match
         FastlaneCore::ConfigItem.new(key: :verbose,
                                      env_name: "MATCH_VERBOSE",
                                      description: "Print out extra information and all commands",
-                                     is_string: false,
+                                     type: Boolean,
                                      default_value: false,
                                      verify_block: proc do |value|
                                        FastlaneCore::Globals.verbose = true if value

data/match/lib/match/runner.rb

@@ -18,6 +18,7 @@ module Match
 
     attr_accessor :storage
 
+    # rubocop:disable Metrics/PerceivedComplexity
     def run(params)
       self.files_to_commit = []
 
@@ -38,6 +39,7 @@ module Match
         git_user_email: params[:git_user_email],
         clone_branch_directly: params[:clone_branch_directly],
         git_basic_authorization: params[:git_basic_authorization],
+        git_bearer_authorization: params[:git_bearer_authorization],
         type: params[:type].to_s,
         generate_apple_certs: params[:generate_apple_certs],
         platform: params[:platform].to_s,
@@ -78,13 +80,21 @@ module Match
       # 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)
+          spaceship.bundle_identifier_exists(username: params[:username], app_identifier: app_identifier, platform: params[:platform])
         end
       end
 
       # Certificate
       cert_id = fetch_certificate(params: params, working_directory: storage.working_directory)
-      spaceship.certificate_exists(username: params[:username], certificate_id: cert_id) if spaceship
+
+      # Mac Installer Distribution Certificate
+      additional_cert_types = params[:additional_cert_types] || []
+      cert_ids = additional_cert_types.map do |additional_cert_type|
+        fetch_certificate(params: params, working_directory: storage.working_directory, specific_cert_type: additional_cert_type)
+      end
+
+      cert_ids << cert_id
+      spaceship.certificates_exists(username: params[:username], certificate_ids: cert_ids, platform: params[:platform]) if spaceship
 
       # Provisioning Profiles
       unless params[:skip_provisioning_profiles]
@@ -118,6 +128,7 @@ module Match
     ensure
       storage.clear_changes if storage
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     # Used when creating a new certificate or profile
     def prefixed_working_directory
@@ -132,8 +143,8 @@ module Match
       end
     end
 
-    def fetch_certificate(params: nil, working_directory: nil)
-      cert_type = Match.cert_type_sym(params[:type])
+    def fetch_certificate(params: nil, working_directory: nil, specific_cert_type: nil)
+      cert_type = Match.cert_type_sym(specific_cert_type || params[:type])
 
       certs = Dir[File.join(prefixed_working_directory, "certs", cert_type.to_s, "*.cer")]
       keys = Dir[File.join(prefixed_working_directory, "certs", cert_type.to_s, "*.p12")]
@@ -141,7 +152,7 @@ module Match
       if certs.count == 0 || keys.count == 0
         UI.important("Couldn't find a valid code signing identity 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, prefixed_working_directory)
+        cert_path = Generator.generate_certificate(params, cert_type, prefixed_working_directory, specific_cert_type: specific_cert_type)
         private_key_path = cert_path.gsub(".cer", ".p12")
 
         self.files_to_commit << cert_path
@@ -195,13 +206,15 @@ module Match
       prov_type = Match.profile_type_sym(params[:type])
 
       names = [Match::Generator.profile_type_name(prov_type), app_identifier]
-      if params[:platform].to_s != :ios.to_s
+      if params[:platform].to_s == :tvos.to_s
         names.push(params[:platform])
       end
 
       profile_name = names.join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
       base_dir = File.join(prefixed_working_directory, "profiles", prov_type.to_s)
-      profiles = Dir[File.join(base_dir, "#{profile_name}.mobileprovision")]
+
+      extension = params[:platform].to_s == :macos.to_s ? ".provisionprofile" : ".mobileprovision"
+      profiles = Dir[File.join(base_dir, "#{profile_name}#{extension}")]
       if Helper.mac?
         keychain_path = FastlaneCore::Helper.keychain_path(params[:keychain_name]) unless params[:keychain_name].nil?
       end
@@ -253,7 +266,7 @@ module Match
         FileUtils.cp(profile, params[:output_path])
       end
 
-      if spaceship && !spaceship.profile_exists(username: params[:username], uuid: uuid)
+      if spaceship && !spaceship.profile_exists(username: params[:username], uuid: uuid, platform: params[:platform])
         # This profile is invalid, let's remove the local file and generate a new one
         File.delete(profile)
         # This method will be called again, no need to modify `files_to_commit`

data/match/lib/match/spaceship_ensure.rb

@@ -28,8 +28,8 @@ module Match
       return Spaceship.client.team_id
     end
 
-    def bundle_identifier_exists(username: nil, app_identifier: nil)
-      found = Spaceship.app.find(app_identifier)
+    def bundle_identifier_exists(username: nil, app_identifier: nil, platform: nil)
+      found = Spaceship.app.find(app_identifier, mac: platform == "macos")
       return if found
 
       require 'sigh/runner'
@@ -45,24 +45,34 @@ module Match
       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
+    def certificates_exists(username: nil, certificate_ids: [], platform: nil)
+      Spaceship.certificate.all(mac: platform == "macos").each do |cert|
+        certificate_ids.delete(cert.id)
       end
-      return if found
+      return if certificate_ids.empty?
 
-      UI.error("Certificate '#{certificate_id}' (stored in your storage) is not available on the Developer Portal")
+      certificate_ids.each do |certificate_id|
+        UI.error("Certificate '#{certificate_id}' (stored in your storage) is not available on the Developer Portal")
+      end
       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|
+    def profile_exists(username: nil, uuid: nil, platform: nil)
+      is_mac = platform == "macos"
+      found = Spaceship.provisioning_profile.all(mac: is_mac).find do |profile|
         profile.uuid == uuid
       end
 
+      # Look for iOS after looking for macOS (needed for Catalyst apps)
+      if !found && is_mac
+        found = Spaceship.provisioning_profile.all(mac: false).find do |profile|
+          profile.uuid == uuid
+        end
+      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

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

@@ -18,6 +18,7 @@ module Match
       attr_accessor :type
       attr_accessor :platform
       attr_accessor :git_basic_authorization
+      attr_accessor :git_bearer_authorization
 
       def self.configure(params)
         return self.new(
@@ -30,7 +31,8 @@ module Match
           git_full_name: params[:git_full_name],
           git_user_email: params[:git_user_email],
           clone_branch_directly: params[:clone_branch_directly],
-          git_basic_authorization: params[:git_basic_authorization]
+          git_basic_authorization: params[:git_basic_authorization],
+          git_bearer_authorization: params[:git_bearer_authorization]
         )
       end
 
@@ -43,7 +45,8 @@ module Match
                      git_full_name: nil,
                      git_user_email: nil,
                      clone_branch_directly: false,
-                     git_basic_authorization: nil)
+                     git_basic_authorization: nil,
+                     git_bearer_authorization: nil)
         self.git_url = git_url
         self.shallow_clone = shallow_clone
         self.skip_docs = skip_docs
@@ -52,6 +55,7 @@ module Match
         self.git_user_email = git_user_email
         self.clone_branch_directly = clone_branch_directly
         self.git_basic_authorization = git_basic_authorization
+        self.git_bearer_authorization = git_bearer_authorization
 
         self.type = type if type
         self.platform = platform if platform
@@ -69,7 +73,11 @@ module Match
         self.working_directory = Dir.mktmpdir
 
         command = "git clone #{self.git_url.shellescape} #{self.working_directory.shellescape}"
-        command << " -c http.extraheader='AUTHORIZATION: basic #{self.git_basic_authorization}'" unless self.git_basic_authorization.nil?
+        # HTTP headers are supposed to be be case insensitive but
+        # Bitbucket requires `Authorization: Basic` and `Authorization Bearer` to work
+        # https://github.com/fastlane/fastlane/pull/15928
+        command << " -c http.extraheader='Authorization: Basic #{self.git_basic_authorization}'" unless self.git_basic_authorization.nil?
+        command << " -c http.extraheader='Authorization: Bearer #{self.git_bearer_authorization}'" unless self.git_bearer_authorization.nil?
 
         if self.shallow_clone
           command << " --depth 1 --no-single-branch"

data/pilot/lib/pilot/build_manager.rb

@@ -39,17 +39,25 @@ module Pilot
 
       UI.success("Successfully uploaded the new binary to App Store Connect")
 
+      # We will fully skip waiting for build processing *only* if no changelog is supplied
+      # Otherwise we may partially wait until the build appears so the changelog can be set, and then bail.
+      return_when_build_appears = false
       if config[:skip_waiting_for_build_processing]
-        UI.important("Skip waiting for build processing")
-        UI.important("This means that no changelog will be set and no build will be distributed to testers")
-        return
+        if config[:changelog].nil?
+          UI.important("`skip_waiting_for_build_processing` used and no `changelog` supplied - skipping waiting for build processing")
+          return
+        else
+          return_when_build_appears = true
+        end
       end
 
       # Calling login again here is needed if login was not called during 'start'
       login unless should_login_in_start
 
       UI.message("If you want to skip waiting for the processing to be finished, use the `skip_waiting_for_build_processing` option")
-      latest_build = wait_for_build_processing_to_be_complete
+      UI.message("Note that if `skip_waiting_for_build_processing` is used but a `changelog` is supplied, this process will wait for the build to appear on AppStoreConnect, update the changelog and then skip the remaining of the processing steps.")
+
+      latest_build = wait_for_build_processing_to_be_complete(return_when_build_appears)
       distribute(options, build: latest_build)
     end
 
@@ -80,11 +88,20 @@ module Pilot
       end
     end
 
-    def wait_for_build_processing_to_be_complete
+    def wait_for_build_processing_to_be_complete(return_when_build_appears = false)
       platform = fetch_app_platform
       app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
       app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
-      latest_build = FastlaneCore::BuildWatcher.wait_for_build_processing_to_be_complete(app_id: app.id, platform: platform, app_version: app_version, build_version: app_build, poll_interval: config[:wait_processing_interval], return_spaceship_testflight_build: false)
+
+      latest_build = FastlaneCore::BuildWatcher.wait_for_build_processing_to_be_complete(
+        app_id: app.id,
+        platform: platform,
+        app_version: app_version,
+        build_version: app_build,
+        poll_interval: config[:wait_processing_interval],
+        return_when_build_appears: return_when_build_appears,
+        return_spaceship_testflight_build: false
+      )
 
       unless latest_build.app_version == app_version && latest_build.version == app_build
         UI.important("Uploaded app #{app_version} - #{app_build}, but received build #{latest_build.app_version} - #{latest_build.version}.")
@@ -137,6 +154,14 @@ module Pilot
           UI.success("Deleted beta app review submission for previous build: #{waiting_for_review_build.app_version} - #{waiting_for_review_build.version}")
         end
       end
+
+      if !build.ready_for_internal_testing? && options[:skip_waiting_for_build_processing]
+        # Meta can be uploaded for a build still in processing
+        # Returning before distribute if skip_waiting_for_build_processing
+        # because can't distribute an app that is still processing
+        return
+      end
+
       distribute_build(build, options)
       type = options[:distribute_external] ? 'External' : 'Internal'
       UI.success("Successfully distributed build to #{type} testers 🚀")
@@ -220,12 +245,21 @@ module Pilot
     end
 
     def self.truncate_changelog(changelog)
-      max_changelog_length = 4000
-      if changelog && changelog.length > max_changelog_length
-        original_length = changelog.length
-        bottom_message = "..."
-        changelog = "#{changelog[0...max_changelog_length - bottom_message.length]}#{bottom_message}"
-        UI.important("Changelog has been truncated since it exceeds Apple's #{max_changelog_length} character limit. It currently contains #{original_length} characters.")
+      max_changelog_bytes = 4000
+      if changelog
+        changelog_bytes = changelog.unpack('C*').length
+        if changelog_bytes > max_changelog_bytes
+          UI.important("Changelog will be truncated since it exceeds Apple's #{max_changelog_bytes}-byte limit. It currently contains #{changelog_bytes} bytes.")
+          new_changelog = ''
+          new_changelog_bytes = 0
+          max_changelog_bytes -= 3 # Will append '...' later.
+          changelog.chars.each do |char|
+            new_changelog_bytes += char.unpack('C*').length
+            break if new_changelog_bytes >= max_changelog_bytes
+            new_changelog += char
+          end
+          changelog = new_changelog + '...'
+        end
       end
       changelog
     end