Module: AnnFlavorCocoapods::PodfileHelper

Defined in:
lib/ann_flavor_cocoapods/podfile_helper.rb

Class Method Summary collapse

Class Method Details

.assert_icon_generated!(user_project, flavor_key, icon_name) ⇒ Object

Fails pod install loudly for a flavor whose .appiconset directory hasn't been generated yet, instead of silently shipping a build with no app icon. ASSETCATALOG_COMPILER_APPICON_NAME is set unconditionally by sync (ios_generator.dart) before "Generate App Icons" has necessarily ever run for that flavor — without this check, Xcode just can't find the named appiconset at build time and ships a blank/default icon with no error anywhere in the pipeline. project_dir is the .xcodeproj's own containing directory (ios/), matching the SRCROOT-relative paths used everywhere else in this method's caller.



502
503
504
505
506
507
508
509
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 502

def self.assert_icon_generated!(user_project, flavor_key, icon_name)
  appiconset_dir = File.join(user_project.project_dir.to_s, 'ann', 'Assets.xcassets', "#{icon_name}.appiconset")
  return if Dir.exist?(appiconset_dir)

  raise "[ann-flavor-cocoapods] Missing app icon for flavor '#{flavor_key}': " \
    "#{appiconset_dir} does not exist. Run \"Generate App Icons\" (Studio) or " \
    "the equivalent icon-generation step for this flavor before running pod install."
end

.assert_swift_version(target, swift_version) ⇒ Object 



230
231
232
233
234
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 230

def self.assert_swift_version(target, swift_version)
  target.build_configuration_list.build_configurations.each do |config|
    config.build_settings['SWIFT_VERSION'] = swift_version
  end
end

.build_type_keys(flavor) ⇒ Object

Build types to generate configurations for: always debug + release (matching ios_generator.dart's _generateXcconfigs union logic exactly, not the core's STANDARD_BUILD_TYPES, which unconditionally includes profile) plus any custom build_types configured on this flavor or the platform default.



459
460
461
462
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 459

def self.build_type_keys(flavor)
  keys = %w[debug release] + flavor.build_types.keys
  keys.uniq
end

.bundle_id_for_build_type(flavor_key, build_type, project_root: nil) ⇒ Object

Returns the bundle ID for a given flavor key and build type (e.g. "debug"), applying build_types.id_suffix from either flavor or default. An unknown flavor key falls back to the unsuffixed default id (matches pre-delegation behavior — this method never raises for a missing flavor).



308
309
310
311
312
313
314
315
316
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 308

def self.bundle_id_for_build_type(flavor_key, build_type, project_root: nil)
  project_root ||= File.dirname(SpecLoader.find_spec_file(Dir.pwd) ||
    raise("annspec.yaml not found (searched upward from #{Dir.pwd})"))
  spec = load_core_spec(project_root)
  ios  = spec.app&.ios
  return '' if ios.nil?

  AnnFlavorCore::IosResolution.bundle_id(ios, flavor_key, build_type)
end

.configure_build_configuration(target, user_project, xcode_config, xcconfig_path, info_plist_path, icon_name) ⇒ Object 



545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 545

def self.configure_build_configuration(target, user_project, xcode_config, xcconfig_path, info_plist_path, icon_name)
  config_list = target.build_configuration_list
  config = config_list[xcode_config]

  unless config
    config = user_project.new(Xcodeproj::Project::Object::XCBuildConfiguration)
    config.name = xcode_config
    # Copy an existing target-level config's settings as a starting point,
    # but strip the product-identity keys this method sets below via the
    # xcconfig include — a literal key in this configuration's OWN
    # buildSettings dict always wins over anything pulled in via
    # baseConfigurationReference, so copying Flutter's own stock
    # PRODUCT_BUNDLE_IDENTIFIER placeholder here (present on the "Debug"
    # config `flutter create` generates) would silently shadow the
    # per-flavor xcconfig value at actual `xcodebuild` time, no matter
    # what the xcconfig itself says (found via STEP-2.11 real-project
    # verification).
    source_settings = config_list.build_configurations.first&.build_settings || {}
    config.build_settings = source_settings.reject { |k, _| PROJECT_LEVEL_EXCLUDED_KEYS.include?(k) }
    config_list.build_configurations << config
  end

  xcconfig_ref = user_project.files.find { |f| f.path == xcconfig_path } ||
    user_project.main_group.new_reference(xcconfig_path)
  config.base_configuration_reference = xcconfig_ref

  config.build_settings['INFOPLIST_FILE'] = info_plist_path
  config.build_settings['ASSETCATALOG_COMPILER_APPICON_NAME'] = icon_name
  # flutter create's own stock Debug/Release configs never set
  # MARKETING_VERSION at all (confirmed against a real project) --
  # CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)" is present on the
  # stock template and so gets copied forward via source_settings above,
  # but there was never an equivalent MARKETING_VERSION bridge to copy.
  # Without this, $MARKETING_VERSION (and therefore
  # CFBundleShortVersionString, App Store Connect's displayed version,
  # and this tooling's own [ann-flavor] Print Build Info line) resolves
  # empty on every per-flavor configuration.
  config.build_settings['MARKETING_VERSION'] = '$(FLUTTER_BUILD_NAME)'

  project_config_list = user_project.root_object.build_configuration_list
  unless project_config_list[xcode_config]
    project_config = user_project.new(Xcodeproj::Project::Object::XCBuildConfiguration)
    project_config.name = xcode_config
    source_settings = project_config_list.build_configurations.first&.build_settings || {}
    project_config.build_settings = source_settings.reject { |k, _| PROJECT_LEVEL_EXCLUDED_KEYS.include?(k) }
    project_config_list.build_configurations << project_config
  end
end

.configure_build_settings(installer, project_root: nil) ⇒ Object

Call inside your Podfile's post_integrate hook, alongside configure_firebase, to create/update the per-flavor Xcode build configurations, scheme, and asset-catalog wiring that the ios/ann/ generated files (xcconfig, Info.plist, Assets.xcassets) depend on. Closes the previously-silent, undocumented manual Xcode step (Project → Info → Configurations → duplicate/rename/assign xcconfig) that every prior consumer had to discover on their own — see plan 035 (docs/03-planning/features/035-ios-flavor-architecture-redesign.md).

Example Podfile usage:

post_integrate do |installer|
AnnFlavorCocoapods::PodfileHelper.configure_firebase(installer)
AnnFlavorCocoapods::PodfileHelper.configure_build_settings(installer)
end

For each flavor x release (plus any custom build_types — the same union logic ios_generator.dart uses for xcconfig file generation):

1. Find-or-create an XCBuildConfiguration named "<BuildType>-<flavor>" on
 the app target.
2. Point baseConfigurationReference at ios/ann/xcconfig/<Flavor><BuildType>.xcconfig.
3. Set INFOPLIST_FILE to ios/ann/Info/Info-<flavor>.plist.
4. Find-or-create the ios/ann/Assets.xcassets catalog reference (once,
 shared across flavors) and set ASSETCATALOG_COMPILER_APPICON_NAME.
5. Find-or-create the flavor's .xcscheme, merge-if-exists (only the
 buildConfiguration= references are touched, preserving any manually
 added scheme content).
6. Inject the "[ann-flavor] Print Build Info" pre-build phase (first in
 the build-phase list), gated by debug.print_build_and_flavor_info.

All steps are idempotent by construction (find-or-create by name) — no drift between "missing" and "wrong value" the way an additive-only patch or a blind overwrite would have.



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
183
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
222
223
224
225
226
227
228
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 135

def self.configure_build_settings(installer, project_root: nil)
  project_root ||= File.dirname(SpecLoader.find_spec_file(Dir.pwd) ||
    raise("annspec.yaml not found (searched upward from #{Dir.pwd})"))
  spec = load_core_spec(project_root)

  ios = spec.app&.ios
  return if ios.nil?
  return if ios.flavors.empty?
  return if installer.nil?

  print_build_info = spec.debug_config.nil? || spec.debug_config.print_build_and_flavor_info != false
  swift_version = ios.default.sdk&.swift_version

  touched_projects = []

  installer.aggregate_targets.each do |aggregate_target|
    user_project = aggregate_target.user_project
    next if user_project.nil?

    user_project.native_targets.each do |target|
      if target.symbol_type == :application
        find_or_create_icon_catalog(target, user_project)

        ios.flavors.each_key do |flavor_key|
          flavor = ios.flavors[flavor_key]

          build_type_keys(flavor).each do |bt|
            xcode_config = "#{bt.capitalize}-#{flavor_key}"
            # Relative to SRCROOT/PROJECT_DIR, which xcodebuild resolves as
            # the .xcodeproj's own containing directory (ios/), NOT the
            # Flutter project root -- confirmed via `xcodebuild
            # -showBuildSettings`'s own SRCROOT value (found via STEP-2.11
            # real-project verification: with a leading "ios/" prefix here,
            # both paths silently resolved to the doubled, nonexistent
            # ios/ios/ann/... and Xcode read neither the xcconfig's values
            # nor the per-flavor Info.plist, with no error at pod install
            # OR build time -- showBuildSettings even echoes the literal
            # unresolved INFOPLIST_FILE string back, so it looked correct
            # until checked against what the xcconfig #include actually
            # applied).
            xcconfig_path = "ann/xcconfig/#{flavor_key}#{bt.capitalize}.xcconfig"
            info_plist_path = "ann/Info/Info-#{flavor_key}.plist"
            icon_name = "#{flavor_key.capitalize}AppIcon"

            assert_icon_generated!(user_project, flavor_key, icon_name)

            configure_build_configuration(
              target, user_project, xcode_config, xcconfig_path, info_plist_path,
              icon_name
            )
          end

          configure_scheme(target, user_project, flavor_key)
        end

        if print_build_info
          inject_build_info_phase(target)
        end
      end

      # Fixes a real pod-install failure: PBXNativeTarget#resolved_build_setting
      # checks a target against EVERY configuration name that exists
      # anywhere in the project (its own configs AND every project-level
      # config name), not just the target's own list -- a name the target
      # has no configuration for resolves to nil rather than being
      # skipped. Runner gets Debug-<flavor>/Release-<flavor> configs (via
      # configure_build_configuration above and the project-level mirror
      # it creates), but this plugin never gave RunnerTests (or any other
      # non-application target) equivalent per-flavor configs -- so for
      # every flavor name, RunnerTests resolves SWIFT_VERSION to nil while
      # Runner resolves to a real value, and CocoaPods rejects the project
      # ("There may only be up to 1 unique SWIFT_VERSION per target").
      # Confirmed directly against a real project: `target
      # .resolved_build_setting('SWIFT_VERSION', true)` returned
      # {"Debug"=>"5.0", ..., "Debug-ledger_in"=>nil, ...} for RunnerTests,
      # even though its own Debug/Release/Profile configs already had an
      # explicit, consistent SWIFT_VERSION.
      #
      # The fix mirrors every project-level configuration name onto this
      # target too (not just :application), each an explicit-SWIFT_VERSION
      # config with no other build settings and no xcconfig -- these
      # names only need to exist and resolve consistently, not carry any
      # of Runner's per-flavor app-identity settings.
      if swift_version
        assert_swift_version(target, swift_version)
        mirror_project_configuration_names(target, user_project, swift_version)
      end

      touched_projects << user_project unless touched_projects.include?(user_project)
    end
  end

  touched_projects.each(&:save)
end

.configure_firebase(installer, project_root: nil) ⇒ Object

Call inside your Podfile's post_integrate hook to wire per-flavor Firebase GoogleService-Info.plist into the Xcode build. Must be post_integrate, not post_install (DEF-061, #61): post_install fires before CocoaPods has integrated/saved the user's app project, so build phases injected there never reach the real app target's build graph — only post_integrate runs after the app project has been integrated and saved.

Example Podfile usage:

require 'ann_flavor_cocoapods'
post_integrate do |installer|
AnnFlavorCocoapods::PodfileHelper.configure_firebase(installer)
end

For each iOS flavor that has config_file set, this injects a pre-build shell script phase into the app target (identified by product type, not a hardcoded name) in the real user Xcode project (Runner.xcodeproj, not CocoaPods' generated Pods.xcodeproj) that copies the correct plist to $SRCROOT/Runner/GoogleService-Info.plist at build time, overwriting whatever was there before.

Deliberately does NOT delete the copied plist after the build (a prior design did, as a post-build phase) — that combination is unsafe: the pre-build phase declares GoogleService-Info.plist as its output_paths (required so Xcode's build system knows the script produces the file, rather than failing Copy Bundle Resources with "Build input file cannot be found" before any script has run), but Xcode's incremental build system can then skip re-running the pre-build script on a later build once it considers that declared output already satisfied — while a post-build phase had already deleted it at the end of the prior build, permanently leaving Runner/GoogleService-Info.plist (and therefore the shipped .app) without a Firebase config for the next incremental build. ios/Runner/GoogleService-Info.plist is gitignored, so leaving the last-built flavor's copy on disk between builds is safe — it is always overwritten fresh by the pre-build phase before the next real build.

Gate: only runs when integrations.firebase is true in annspec.yaml.



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
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 44

def self.configure_firebase(installer, project_root: nil)
  project_root ||= File.dirname(SpecLoader.find_spec_file(Dir.pwd) ||
    raise("annspec.yaml not found (searched upward from #{Dir.pwd})"))
  spec = load_core_spec(project_root)

  # integrations.firebase must be explicitly enabled (REQ-FIRE-00010).
  return unless spec.app&.integrations&.firebase == true

  ios = spec.app&.ios
  return if ios.nil?

  layout = detect_project_layout(project_root)

  # Build a map: configuration_name → config_file path.
  # Xcode configuration names are capitalized: Release-<flavor>, Debug-<flavor>.
  config_map = {}
  ios.flavors.each_key do |flavor_key|
    AnnFlavorCore::Resolver::STANDARD_BUILD_TYPES.each do |bt|
      fb_file = AnnFlavorCore::IosResolution.firebase_config_path(
        ios, flavor_key, bt, generated_dir: layout[:generated_dir]
      )
      next unless fb_file

      # Map Xcode config name (e.g. "Release-ledger_in") → plist path
      xcode_config = "#{bt.capitalize}-#{flavor_key}"
      config_map[xcode_config] = fb_file

      warn_if_static_plist(project_root, xcode_config, fb_file)
    end
  end

  return if config_map.empty?
  return if installer.nil?

  inject_build_phases(installer, project_root, config_map)
end

.configure_scheme(target, user_project, flavor_key) ⇒ Object

Find-or-create the flavor's .xcscheme at the fixed Xcode-mandated path, merge-if-exists: only the buildConfiguration= references this tooling owns are (re)set, leaving any manually-added scheme content (env vars, launch arguments, test configuration) untouched — unlike the prior Studio/Kotlin generator, which blindly overwrote the whole file on every run.

Schemes are consulted only by Xcode's GUI scheme picker; the CLI/CI build path (flutter build ipa --flavor X) invokes xcodebuild -configuration directly and never reads scheme files at all — this step exists purely for developer ergonomics, not build correctness.



604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 604

def self.configure_scheme(target, user_project, flavor_key)
  project_path = user_project.path.to_s
  scheme_path = Xcodeproj::XCScheme.shared_data_dir(project_path) + "#{flavor_key}.xcscheme"

  scheme = File.exist?(scheme_path.to_s) ? Xcodeproj::XCScheme.new(scheme_path.to_s) : Xcodeproj::XCScheme.new
  scheme.configure_with_targets(target, nil, launch_target: true)

  scheme.test_action.build_configuration    = "Debug-#{flavor_key}"
  scheme.launch_action.build_configuration  = "Debug-#{flavor_key}"
  scheme.profile_action.build_configuration = "Release-#{flavor_key}"
  scheme.analyze_action.build_configuration = "Debug-#{flavor_key}"
  scheme.archive_action.build_configuration = "Release-#{flavor_key}"

  scheme.save_as(project_path, flavor_key)
end

.detect_project_layout(project_root) ⇒ Object

Detects whether project_root is a Flutter project (has pubspec.yaml, so generated Firebase files live under lib/generated/firebase/) or a plain iOS-only Xcode project with no Flutter wrapper (no pubspec.yaml — ios/ itself is the effective root, so generated Firebase files live under ios/generated/firebase/ instead, since there is no lib/ to nest under). Either way, the returned generated_dir is relative to project_root, and for the real Runner target $SRCROOT is always <project_root>/ios — one level below project_root — so inject_build_phases always needs exactly one ".." hop to reach it, regardless of layout.

Resolved once here, at pod install time, rather than probed for at build time inside the generated shell script — a runtime "try here, then try one level up" fallback would mask a genuinely wrong layout instead of surfacing it, exactly the failure mode already fixed once in this file (DEF-061, #61 and the 0.1.22/0.1.23 stale-path bugs).



96
97
98
99
100
101
102
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 96

def self.detect_project_layout(project_root)
  if File.exist?(File.join(project_root, 'pubspec.yaml'))
    { generated_dir: 'lib/generated/firebase' }
  else
    { generated_dir: 'ios/generated/firebase' }
  end
end

.ensure_plist_in_resources(target, user_project) ⇒ Object

Find-or-create a file reference for Runner/GoogleService-Info.plist and add it to the target's Resources build phase (Copy Bundle Resources), so the file the pre-build script copies onto disk actually gets packaged into the built .app — a reference-only membership check (idempotent, no duplicate entries across repeated pod install runs).



444
445
446
447
448
449
450
451
452
453
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 444

def self.ensure_plist_in_resources(target, user_project)
  runner_group = user_project.main_group.find_subpath('Runner', false)
  return if runner_group.nil?

  existing = runner_group.children.find { |c| c.path == 'GoogleService-Info.plist' }
  ref = existing || runner_group.new_reference('GoogleService-Info.plist')
  ref.last_known_file_type = 'text.plist.xml'

  target.resources_build_phase.add_file_reference(ref, true)
end

.find_or_create_icon_catalog(target, user_project) ⇒ Object

Find-or-create the ios/ann/Assets.xcassets catalog's own file reference, added once to the target's Resources build phase and shared across every flavor — only the per-flavor .appiconset contents inside it vary (wired via ASSETCATALOG_COMPILER_APPICON_NAME on each build configuration, not by the file reference itself).



469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 469

def self.find_or_create_icon_catalog(target, user_project)
  group = user_project.main_group.find_subpath('ann', true)
  # find_subpath('ann', true) creates the group via Xcodeproj's new_group('ann')
  # when it doesn't already exist -- that only sets the group's NAME, never its
  # PATH. A <group>-sourceTree PBXGroup with a name but no path contributes
  # nothing to its children's resolved filesystem path, so the Assets.xcassets
  # reference below silently resolved to ios/Assets.xcassets instead of
  # ios/ann/Assets.xcassets -- the actual generated catalog's real location
  # (ios_icon_generator.dart writes to ios/ann/Assets.xcassets/). Xcode then
  # can't find the per-flavor .appiconset at build time, even though the files
  # are correctly on disk. Setting the path explicitly (idempotent -- a no-op
  # once already set) fixes the resolved location without touching the group's
  # display name.
  group.set_path('ann') if group.path.nil?
  existing = group.children.find { |c| c.path == 'Assets.xcassets' }

  ref = existing || group.new_reference('Assets.xcassets')
  ref.last_known_file_type = 'folder.assetcatalog'

  target.resources_build_phase.add_file_reference(ref, true)

  ref
end

.inject_build_info_phase(target) ⇒ Object

Injects a pre-build phase that prints resolved build/flavor info before any compilation step — iOS parity with Android's PreBuildProcessingTask (plugins/ann-flavor-gradle/.../tasks/PreBuildProcessing.kt). Positioned first in the build-phase list so it fires ahead of the Firebase-copy phase too.

Unlike Android's task, which re-resolves the cascade in Kotlin at Gradle-task-execution time, this reads already-resolved Xcode build-setting environment variables — by the time this phase runs, Xcode has already selected the Debug-/Release- configuration and its xcconfig, so no re-parsing of annspec.yaml is needed here.



630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 630

def self.inject_build_info_phase(target)
  target.build_phases.reject! { |p| p.respond_to?(:name) && p.name == '[ann-flavor] Print Build Info' }

  script = <<~SHELL
    # Injected by ann-flavor-cocoapods: print build info
    # $CONFIGURATION is "<BuildType>-<flavor>" (e.g. "Debug-ledger_in") for
    # a flavor build -- split it so the flavor key has its own labeled line
    # instead of only appearing embedded inside Build Type.
    FLAVOR_NAME="${CONFIGURATION#*-}"
    if [ "$FLAVOR_NAME" = "$CONFIGURATION" ]; then
      FLAVOR_NAME="(none)"
    fi
    BUILD_INFO=$(cat <<EOF
    🛠 Build Information 🛠
    \t🔹 Build Type:    $CONFIGURATION
    \t🔹 Flavor:        $FLAVOR_NAME
    \t🔹 App Name:      $APP_NAME
    \t🔹 App ID:        $PRODUCT_BUNDLE_IDENTIFIER
    \t🔹 Version Name:  $MARKETING_VERSION
    \t🔹 Version Code:  $CURRENT_PROJECT_VERSION
    EOF
    )
    echo "$BUILD_INFO"
    # Also written to build_info.log so it's readable without Xcode's own
    # build log or `flutter run -v` -- e.g. `tail -f ios/build_info.log`
    # in a separate terminal while `flutter run` is going. Overwritten
    # fresh on every build, one level below $SRCROOT (ios/), so it always
    # reflects the most recently built flavor.
    echo "$BUILD_INFO" > "${SRCROOT}/build_info.log"
  SHELL

  phase = target.project.new(Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
  phase.name = '[ann-flavor] Print Build Info'
  phase.shell_path = '/bin/sh'
  phase.shell_script = script
  phase.show_env_vars_in_log = '0'
  target.build_phases.unshift(phase)
end

.inject_build_phases(installer, project_root, config_map) ⇒ Object

Injects a pre-build shell script phase into the real app target (identified by product type) inside the user's own Xcode project — NOT installer.pods_project (CocoaPods' generated Pods.xcodeproj, whose Pods-Runner aggregate target only builds pod dependencies and can never satisfy the app target's own build graph — DEF-061, #61).



344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 344

def self.inject_build_phases(installer, project_root, config_map)
  # Build the per-config shell that selects the right source file.
  # Uses a case statement keyed on $CONFIGURATION (Xcode build setting).
  # plist_path is always relative to project_root (either
  # lib/generated/firebase/... for a Flutter project, or
  # ios/generated/firebase/... for an iOS-only project — see
  # detect_project_layout); for the real Runner target (fixed by
  # DEF-061, #61) $SRCROOT is <project_root>/ios, one level below
  # project_root regardless of layout — a single ".." reaches it in both
  # cases. (The old ".." x2 was seemingly sized for Pods-Runner's
  # $SRCROOT, one level deeper still inside CocoaPods' generated
  # Pods.xcodeproj, but that build phase never actually ran there either,
  # so this was never previously exercised.)
  case_body = config_map.map do |xcode_config, plist_path|
    "  #{xcode_config}) SRC_PLIST=\"${SRCROOT}/../#{plist_path}\" ;;"
  end.join("\n")

  pre_build_script = <<~SHELL
    # Injected by ann-flavor-cocoapods: copy per-flavor GoogleService-Info.plist
    case "$CONFIGURATION" in
    #{case_body}
      *) echo "ann-flavor-cocoapods: no Firebase plist for $CONFIGURATION"; exit 0 ;;
    esac
    DEST="${SRCROOT}/Runner/GoogleService-Info.plist"
    if [ ! -f "$SRC_PLIST" ]; then
      MSG="ann-flavor-cocoapods ERROR: Firebase plist not found: $SRC_PLIST"
      echo "$MSG"
      echo "$MSG" >> "${SRCROOT}/build_info.log"
      exit 1
    fi
    cp "$SRC_PLIST" "$DEST"
    MSG="ann-flavor-cocoapods: copied $SRC_PLIST -> $DEST"
    echo "$MSG"
    # Appended (not overwritten) — [ann-flavor] Print Build Info's phase
    # overwrites build_info.log with $BUILD_INFO earlier in the same
    # build, so this line adds to that, rather than replacing it.
    echo "$MSG" >> "${SRCROOT}/build_info.log"
  SHELL

  # aggregate_targets are the Podfile's own `target 'Runner' do ... end`
  # definitions; each carries a user_project pointing at the real
  # Runner.xcodeproj (not installer.pods_project).
  touched_projects = []

  installer.aggregate_targets.each do |aggregate_target|
    user_project = aggregate_target.user_project
    next if user_project.nil?

    user_project.native_targets.each do |target|
      # Robust across differently-named projects/targets — an app target's
      # product type, not a hardcoded "Runner"/"Pods-Runner" name.
      next unless target.symbol_type == :application

      # Remove any previously-injected phases before re-adding fresh ones.
      # A presence-only check here (skip if a phase with our marker already
      # exists) would leave a stale script baked into project.pbxproj forever
      # once injected once — pod install does not re-read the gem's current
      # script content into an existing phase, so upgrading the gem alone
      # would never fix an already-injected, now-outdated shell_script.
      target.build_phases.reject! do |p|
        p.respond_to?(:name) && ['[ann-flavor] Copy Firebase plist', '[ann-flavor] Remove Firebase plist'].include?(p.name)
      end

      pre  = target.project.new(Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
      pre.name             = '[ann-flavor] Copy Firebase plist'
      pre.shell_path       = '/bin/sh'
      pre.shell_script     = pre_build_script
      pre.show_env_vars_in_log = '0'
      # Declaring the destination as an output file tells Xcode's build system
      # that this script produces the plist — suppresses the "input file not found"
      # error that fires when the plist is referenced in Copy Bundle Resources.
      pre.output_paths     = ['$(SRCROOT)/Runner/GoogleService-Info.plist']
      target.build_phases.unshift(pre)

      # Real bug: the plist was copied into Runner/ on disk by the script
      # above, but never added as a Copy Bundle Resources member — nothing
      # actually packaged it into the built .app, so native Firebase found
      # no GoogleService-Info.plist in the bundle at runtime despite the
      # file existing correctly in the source tree the whole time.
      ensure_plist_in_resources(target, user_project)

      touched_projects << user_project unless touched_projects.include?(user_project)

      puts "ann-flavor-cocoapods: injected Firebase build phase into #{target.name} " \
           "(#{config_map.size} configuration(s))"
    end
  end

  # post_integrate runs after CocoaPods' own save pass for the user project
  # (UserProjectIntegrator#integrate! already saved it before this hook
  # fires) — no later save happens automatically, so these changes are
  # silently lost unless saved explicitly here.
  touched_projects.each(&:save)
end

.load_core_spec(project_root) ⇒ Object

Parses annspec.yaml through the shared core (ADR-008) — the single source of truth for parsing, cascade merging, and resolution.



320
321
322
323
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 320

def self.load_core_spec(project_root)
  path = File.join(project_root, SpecLoader::SPEC_FILE)
  AnnFlavorCore::Parser.parse_file(path)
end

.mirror_project_configuration_names(target, user_project, swift_version) ⇒ Object

Creates a bare XCBuildConfiguration on target, named after every project-level configuration name it doesn't already have one for, with only SWIFT_VERSION set. See the call site's comment for why this is necessary -- PBXNativeTarget#resolved_build_setting resolves every target against every project-level configuration name, and a target with no configuration for a given name resolves to nil there rather than being skipped, which is indistinguishable from a real conflicting value to CocoaPods' single-unique-SWIFT_VERSION-per-target check.

Idempotent -- find-or-create by name, like configure_build_configuration.



246
247
248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 246

def self.mirror_project_configuration_names(target, user_project, swift_version)
  project_config_names = user_project.root_object.build_configuration_list
    .build_configurations.map(&:name)
  target_config_list = target.build_configuration_list

  project_config_names.each do |name|
    next if target_config_list[name]

    config = user_project.new(Xcodeproj::Project::Object::XCBuildConfiguration)
    config.name = name
    config.build_settings = { 'SWIFT_VERSION' => swift_version }
    target_config_list.build_configurations << config
  end
end

.preflight_swift_version(project_root: nil) ⇒ Object

Opens the .xcodeproj directly and applies the same SWIFT_VERSION fix as configure_build_settings' post_integrate path (assert_swift_version + mirror_project_configuration_names on every native target) -- but callable standalone, with no CocoaPods installer object needed.

This exists because pod install's own dependency-resolution/analysis phase (Pod::Installer::Analyzer::TargetInspector#compute_swift_version_from_targets) runs BEFORE any Podfile hook -- pre_install, pre_integrate, post_install, and post_integrate all fire only after analysis has already succeeded. A project whose SWIFT_VERSION is inconsistent across configuration names fails during analysis itself, so configure_build_settings never gets a chance to run and fix it -- confirmed against a real project via Pod::Installer#install!'s call order (resolve_dependencies, which calls analyze, happens before integrate, which is what runs the Podfile hooks). Calling this from sync (a separate process that runs before pod install is ever invoked) fixes the project ahead of time, so a project's very first pod install succeeds too, not just every one after the first.

No-op if sdk.swift_version isn't set, iOS isn't configured, or no .xcodeproj can be found under ios/.



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 282

def self.preflight_swift_version(project_root: nil)
  project_root ||= File.dirname(SpecLoader.find_spec_file(Dir.pwd) ||
    raise("annspec.yaml not found (searched upward from #{Dir.pwd})"))
  spec = load_core_spec(project_root)

  ios = spec.app&.ios
  return if ios.nil? || ios.flavors.empty?

  swift_version = ios.default.sdk&.swift_version
  return if swift_version.nil?

  xcodeproj_path = Dir.glob(File.join(project_root, 'ios', '*.xcodeproj')).first
  return if xcodeproj_path.nil?

  project = Xcodeproj::Project.open(xcodeproj_path)
  project.native_targets.each do |target|
    assert_swift_version(target, swift_version)
    mirror_project_configuration_names(target, project, swift_version)
  end
  project.save
end

.warn_if_static_plist(project_root, xcode_config, config_file) ⇒ Object

Warn if a static GoogleService-Info.plist already exists in the project; a higher-priority static file would shadow the one we copy at build time.



329
330
331
332
333
334
335
336
337
 
# File 'lib/ann_flavor_cocoapods/podfile_helper.rb', line 329

def self.warn_if_static_plist(project_root, xcode_config, config_file)
  static_path = File.join(project_root, 'ios', 'Runner', 'GoogleService-Info.plist')
  if File.exist?(static_path)
    puts "ann-flavor-cocoapods WARNING: A static GoogleService-Info.plist exists at " \
         "ios/Runner/GoogleService-Info.plist. It will be overwritten at build time " \
         "for configuration '#{xcode_config}' (source: #{config_file}). " \
         "Remove the static file to silence this warning."
  end
end