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 



288
289
290
291
292
 
# File 'pilot/lib/pilot/build_manager.rb', line 288

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 



310
311
312
313
314
 
# File 'pilot/lib/pilot/build_manager.rb', line 310

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

.strip_emoji(changelog) ⇒ Object 



294
295
296
297
298
299
300
 
# File 'pilot/lib/pilot/build_manager.rb', line 294

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 



302
303
304
305
306
307
308
 
# File 'pilot/lib/pilot/build_manager.rb', line 302

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 



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'pilot/lib/pilot/build_manager.rb', line 268

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 



82
83
84
85
86
87
88
89
90
 
# File 'pilot/lib/pilot/build_manager.rb', line 82

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 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
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
 
# File 'pilot/lib/pilot/build_manager.rb', line 121

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: 1).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:



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'pilot/lib/pilot/build_manager.rb', line 65

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 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'pilot/lib/pilot/build_manager.rb', line 184

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 



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'pilot/lib/pilot/build_manager.rb', line 223

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
 
# 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 file given") unless config[:ipa]

  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
  package_path = FastlaneCore::IpaUploadPackageBuilder.new.generate(app_id: fetch_app_id,
                                                                  ipa_path: options[:ipa],
                                                              package_path: dir,
                                                                  platform: platform)

  transporter = transporter_for_selected_team(options)
  result = transporter.upload(package_path: package_path)

  unless result
    transporter_errors = transporter.displayable_errors
    UI.user_error!("Error uploading ipa 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
      return_when_build_appears = true
    end
  end

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

  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 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

#wait_for_build_processing_to_be_complete(return_when_build_appears = false) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'pilot/lib/pilot/build_manager.rb', line 92

def wait_for_build_processing_to_be_complete(return_when_build_appears = false)
  platform = fetch_app_platform
  if config[:ipa]
    app_version = FastlaneCore::IpaFileAnalyser.fetch_app_version(config[:ipa])
    app_build = FastlaneCore::IpaFileAnalyser.fetch_app_build(config[:ipa])
  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]
  )

  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