Class: Pilot::BuildManager

Inherits:
Manager
  • Object
show all
Defined in:
pilot/lib/pilot/build_manager.rb

Overview

rubocop:disable Metrics/ClassLength

Instance Attribute Summary

Attributes inherited from Manager

#config

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Manager

#app, #fetch_app_id, #fetch_app_identifier, #fetch_app_platform, #login, #start

Class Method Details

.emoji_regex ⇒ Object 



312
313
314
315
316
 
# File 'pilot/lib/pilot/build_manager.rb', line 312

def self.emoji_regex
  # EmojiRegex::RGIEmoji is now preferred over EmojiRegex::Regex which is deprecated as of 3.2.0
  # https://github.com/ticky/ruby-emoji-regex/releases/tag/v3.2.0
  return defined?(EmojiRegex::RGIEmoji) ? EmojiRegex::RGIEmoji : EmojiRegex::Regex
end

.sanitize_changelog(changelog) ⇒ Object 



334
335
336
337
338
 
# File 'pilot/lib/pilot/build_manager.rb', line 334

def self.sanitize_changelog(changelog)
  changelog = strip_emoji(changelog)
  changelog = strip_less_than_sign(changelog)
  truncate_changelog(changelog)
end

.strip_emoji(changelog) ⇒ Object 



318
319
320
321
322
323
324
 
# File 'pilot/lib/pilot/build_manager.rb', line 318

def self.strip_emoji(changelog)
  if changelog && changelog =~ emoji_regex
    changelog.gsub!(emoji_regex, "")
    UI.important("Emoji symbols have been removed from the changelog, since they're not allowed by Apple.")
  end
  changelog
end

.strip_less_than_sign(changelog) ⇒ Object 



326
327
328
329
330
331
332
 
# File 'pilot/lib/pilot/build_manager.rb', line 326

def self.strip_less_than_sign(changelog)
  if changelog && changelog.include?("<")
    changelog.delete!("<")
    UI.important("Less than signs (<) have been removed from the changelog, since they're not allowed by Apple.")
  end
  changelog
end

.truncate_changelog(changelog) ⇒ Object 



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'pilot/lib/pilot/build_manager.rb', line 292

def self.truncate_changelog(changelog)
  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

Instance Method Details

#check_for_changelog_or_whats_new!(options) ⇒ Object 



102
103
104
105
106
107
108
109
110
 
# File 'pilot/lib/pilot/build_manager.rb', line 102

def check_for_changelog_or_whats_new!(options)
  if !has_changelog_or_whats_new?(options) && options[:distribute_external] == true
    if UI.interactive?
      options[:changelog] = UI.input("No changelog provided for new build. You can provide a changelog using the `changelog` option. For now, please provide a changelog here:")
    else
      UI.user_error!("No changelog provided for new build. Please either disable `distribute_external` or provide a changelog using the `changelog` option")
    end
  end
end

#distribute(options, build: nil) ⇒ Object 



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'pilot/lib/pilot/build_manager.rb', line 145

def distribute(options, build: nil)
  start(options)
  if config[:apple_id].to_s.length == 0 && config[:app_identifier].to_s.length == 0
    config[:app_identifier] = UI.input("App Identifier: ")
  end

  # Get latest uploaded build if no build specified
  if build.nil?
    app_version = config[:app_version]
    build_number = config[:build_number]
    if build_number.nil?
      if app_version.nil?
        UI.important("No build specified - fetching latest build")
      else
        UI.important("No build specified - fetching latest build for version #{app_version}")
      end
    end
    platform = Spaceship::ConnectAPI::Platform.map(fetch_app_platform)
    build ||= Spaceship::ConnectAPI::Build.all(app_id: app.id, version: app_version, build_number: build_number, sort: "-uploadedDate", platform: platform, limit: Spaceship::ConnectAPI::Platform::ALL.size).first
  end

  # Verify the build has all the includes that we need
  # and fetch a new build if not
  if build && (!build.app || !build.build_beta_detail || !build.pre_release_version)
    UI.important("Build did include information for app, build beta detail and pre release version")
    UI.important("Fetching a new build with all the information needed")
    build = Spaceship::ConnectAPI::Build.get(build_id: build.id)
  end

  # Error out if no build
  if build.nil?
    UI.user_error!("No build to distribute!")
  end

  # Update beta app meta info
  # 1. Demo account required
  # 2. App info
  # 3. Localized app  info
  # 4. Localized build info
  # 5. Auto notify enabled with config[:notify_external_testers]
  update_beta_app_meta(options, build)

  return if config[:skip_submission]
  if options[:reject_build_waiting_for_review]
    reject_build_waiting_for_review(build)
  end

  if options[:expire_previous_builds]
    expire_previous_builds(build)
  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 🚀")
end

#has_changelog_or_whats_new?(options) ⇒ Boolean

Returns:



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'pilot/lib/pilot/build_manager.rb', line 85

def has_changelog_or_whats_new?(options)
  # Look for legacy :changelog option
  has_changelog = !options[:changelog].nil?

  # Look for :whats_new in :localized_build_info
  unless has_changelog
    infos_by_lang = options[:localized_build_info] || []
    infos_by_lang.each do |k, v|
      next if has_changelog
      v ||= {}
      has_changelog = v.key?(:whats_new) || v.key?('whats_new')
    end
  end

  return has_changelog
end

#list(options) ⇒ Object 



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'pilot/lib/pilot/build_manager.rb', line 208

def list(options)
  start(options)
  if config[:apple_id].to_s.length == 0 && config[:app_identifier].to_s.length == 0
    config[:app_identifier] = UI.input("App Identifier: ")
  end

  # Get processing builds
  build_deliveries = app.get_build_deliveries.map do |build_delivery|
    [
      build_delivery.cf_build_short_version_string,
      build_delivery.cf_build_version
    ]
  end

  # Get processed builds
  builds = app.get_builds(includes: "betaBuildMetrics,preReleaseVersion", sort: "-uploadedDate").map do |build|
    [
      build.app_version,
      build.version,
      (build.beta_build_metrics || []).map(&:install_count).compact.reduce(:+)
    ]
  end

  # Only show table if there are any build deliveries
  unless build_deliveries.empty?
    puts(Terminal::Table.new(
           title: "#{app.name} Processing Builds".green,
           headings: ["Version #", "Build #"],
           rows: FastlaneCore::PrintTable.transform_output(build_deliveries)
    ))
  end

  puts(Terminal::Table.new(
         title: "#{app.name} Builds".green,
         headings: ["Version #", "Build #", "Installs"],
         rows: FastlaneCore::PrintTable.transform_output(builds)
  ))
end

#update_beta_app_meta(options, build) ⇒ Object 



247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'pilot/lib/pilot/build_manager.rb', line 247

def update_beta_app_meta(options, build)
  # If demo_account_required is a parameter, it should added into beta_app_review_info
  unless options[:demo_account_required].nil?
    options[:beta_app_review_info] = {} if options[:beta_app_review_info].nil?
    options[:beta_app_review_info][:demo_account_required] = options[:demo_account_required]
  end

  if should_update_beta_app_review_info(options)
    update_review_detail(build, options[:beta_app_review_info])
  end

  if should_update_localized_app_information?(options)
    update_localized_app_review(build, options[:localized_app_info])
  elsif should_update_app_test_information?(options)
    default_info = {}
    default_info[:feedback_email] = options[:beta_app_feedback_email] if options[:beta_app_feedback_email]
    default_info[:description] = options[:beta_app_description] if options[:beta_app_description]
    begin
      update_localized_app_review(build, {}, default_info: default_info)
      UI.success("Successfully set the beta_app_feedback_email and/or beta_app_description")
    rescue => ex
      UI.user_error!("Could not set beta_app_feedback_email and/or beta_app_description: #{ex}")
    end
  end

  if should_update_localized_build_information?(options)
    update_localized_build_review(build, options[:localized_build_info])
  elsif should_update_build_information?(options)
    begin
      update_localized_build_review(build, {}, default_info: { whats_new: options[:changelog] })
      UI.success("Successfully set the changelog for build")
    rescue => ex
      UI.user_error!("Could not set changelog: #{ex}")
    end
  end

  if options[:notify_external_testers].nil?
    UI.important("Using App Store Connect's default for notifying external testers (which is true) - set `notify_external_testers` for full control")
  else
    update_build_beta_details(build, {
      auto_notify_enabled: options[:notify_external_testers]
    })
  end
end

#upload(options) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'pilot/lib/pilot/build_manager.rb', line 13

def upload(options)
  # Only need to login before upload if no apple_id was given
  # 'login' will be deferred until before waiting for build processing
   = options[:apple_id].nil?
  start(options, should_login: )

  UI.user_error!("No ipa or pkg file given") if config[:ipa].nil? && config[:pkg].nil?

  if config[:ipa] && config[:pkg]
    UI.important("WARNING: Both `ipa` and `pkg` options are defined either explicitly or with default_value (build found in directory)")
    UI.important("Uploading `ipa` is preferred by default. Set `app_platform` to `osx` to force uploading `pkg`")
  end

  check_for_changelog_or_whats_new!(options)

  UI.success("Ready to upload new build to TestFlight (App: #{fetch_app_id})...")

  dir = Dir.mktmpdir

  platform = fetch_app_platform
  ipa_path = options[:ipa]
  if ipa_path && platform != 'osx'
    asset_path = ipa_path
    package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
                                                                  ipa_path: ipa_path,
                                                              package_path: dir,
                                                                  platform: platform)
  else
    pkg_path = options[:pkg]
    asset_path = pkg_path
    package_path = FastlaneCore::PkgUploadPackageBuilder.new.generate(app_id: fetch_app_id,
                                                                    pkg_path: pkg_path,
                                                                package_path: dir,
                                                                    platform: platform)
  end

  transporter = transporter_for_selected_team(options)
  result = transporter.upload(package_path: package_path, asset_path: asset_path, platform: platform)

  unless result
    transporter_errors = transporter.displayable_errors
    file_type = platform == "osx" ? "pkg" : "ipa"
    UI.user_error!("Error uploading #{file_type} file: \n #{transporter_errors}")
  end

  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]
    if config[:changelog].nil?
      UI.important("`skip_waiting_for_build_processing` used and no `changelog` supplied - skipping waiting for build processing")
      return
    else
      UI.important("`skip_waiting_for_build_processing` used and `changelog` supplied - will wait until build appears on App Store Connect, update the changelog and then skip the rest of the remaining of the processing steps.")
      return_when_build_appears = true
    end
  end

  # Calling login again here is needed if login was not called during 'start'
   unless 

  if config[:skip_waiting_for_build_processing].nil?
    UI.message("If you want to skip waiting for the processing to be finished, use the `skip_waiting_for_build_processing` option")
    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 App Store Connect, update the changelog and then skip the remaining of the processing steps.")
  end

  latest_build = wait_for_build_processing_to_be_complete(return_when_build_appears)
  distribute(options, build: latest_build)
end

#wait_for_build_processing_to_be_complete(return_when_build_appears = false) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'pilot/lib/pilot/build_manager.rb', line 112

def wait_for_build_processing_to_be_complete(return_when_build_appears = false)
  platform = fetch_app_platform
  if config[:ipa] && platform != "osx" && !config[:distribute_only]
    app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
    app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
  elsif config[:pkg] && !config[:distribute_only]
    app_version = FastlaneCore::PkgFileAnalyser.fetch_app_version(config[:pkg])
    app_build = FastlaneCore::PkgFileAnalyser.fetch_app_build(config[:pkg])
  else
    app_version = config[:app_version]
    app_build = config[:build_number]
  end

  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],
    timeout_duration: config[:wait_processing_timeout_duration],
    return_when_build_appears: return_when_build_appears,
    return_spaceship_testflight_build: false,
    select_latest: config[:distribute_only],
    wait_for_build_beta_detail_processing: true
  )

  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}.")
  end

  return latest_build
end