cocoapods-podgenerate 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c23dcfa65c98d07b1facb75c25c0b48c4899886f88397544887c38d95f1d695
-  data.tar.gz: f5a1805ef912d83ce6ac2520b48a40543c76f02634bef505bab121910427fb1a
+  metadata.gz: 27602be6d9b287c0d9b46a5ce44325a4ab1ddfcb47e2b6f0c5d40c6ec59cb904
+  data.tar.gz: 39039a26b13a8504df307e15afe77bc439541baaa5a5d27cce7b39fa7f61fb87
 SHA512:
-  metadata.gz: f2f2628e7f34e56c628f006cdf785fc38df4e37e0e86cd04c52fe155b8eacf398ec656172b9476871438807acf987e13f3894c19501ce99c6e0a7a9cb0bae488
-  data.tar.gz: 81d85b61da2db4da471411f0bc4ec3d4f42513d45a5358a2211c8bd0e352f01e0d02b888c99ef4c2ddf0ae6d12e8248b624eb98dda78e60a8a07691528a270f5
+  metadata.gz: 74077cdbefbb30767526f247b41f17d98ae02e43d644b03bdc8993fd40c1c7b799e4c4b48bb25a18e7b5a40146d0af9dae093161839eaf019ab9970631295f60
+  data.tar.gz: 0306e59218825aae0a218cd756ef04339c53f79c3a2ab69ed255d03b8c84c13900c2cd51f9314a2cb01c1cf8eb7c4eec14e06eada6230009ab0df4b2a68d9247

data/lib/cocoapods-podgenerate/benchmark/profiler.rb

@@ -2,7 +2,7 @@
 
 # [cocoapods-podgenerate]
 # Performance profiler. Hooks into Pod::Installer to time each phase.
-# Output: per-phase wall-clock timing breakdown.
+# Output: per-phase wall-clock timing breakdown with sub-step detail.
 
 module Pod
   module PodGenerate
@@ -23,16 +23,13 @@ module Pod
           def install
             return unless enabled?
             Pod::Installer.prepend(ProfilerHooks)
+            Pod::Installer.prepend(ProfilerSubSteps)
           end
 
           def record_phase(name, duration)
             @phase_timings << [name, duration]
           end
 
-          def swap_or_default(phase_name)
-            # Called from hooks: returns a timing helper or nil
-          end
-
           def report
             return if @phase_timings.empty?
             total = @phase_timings.map(&:last).sum
@@ -43,9 +40,11 @@ module Pod
             end
             Pod::UI.puts "  #{'─' * 50}"
             Pod::UI.puts "  #{format('%-35s', 'TOTAL')} #{format('%.2f', total)}s"
+            @phase_timings.clear
           end
         end
 
+        # Top-level step hooks (v0.1.0)
         module ProfilerHooks
           def install!
             t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -88,6 +87,50 @@ module Pod
             Profiler.record_phase('  Integrate user project', elapsed)
           end
         end
+
+        # Sub-step timing hooks (v0.1.2)
+        module ProfilerSubSteps
+          def stage_sandbox(sandbox, pod_targets)
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+            Profiler.record_phase('    Stage sandbox', elapsed) if elapsed > 0.01
+          end
+
+          def analyze_project_cache
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            result = super
+          ensure
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+            Profiler.record_phase('    Analyze project cache', elapsed) if elapsed > 0.01
+            result
+          end
+
+          def create_and_save_projects(*args)
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+            Profiler.record_phase('    Create and save projects', elapsed) if elapsed > 0.01
+          end
+
+          def update_project_cache(cache_analysis_result, target_installation_results)
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+            Profiler.record_phase('    Update project cache', elapsed) if elapsed > 0.01
+          end
+
+          def write_lockfiles
+            t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+            Profiler.record_phase('  Write lockfiles', elapsed)
+          end
+        end
       end
     end
   end

data/lib/cocoapods-podgenerate/patches/cache_analyzer_patch.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# [cocoapods-podgenerate]
+# Monkey-patches ProjectCacheAnalyzer to parallelize cache key computation.
+#
+# v0.1.2 Optimization:
+#  1. Parallel MD5 cache key computation across all pod targets
+#
+# TargetCacheKey.from_pod_target computes MD5 checksums of build settings
+# and collects resource dependencies per target. Each computation is fully
+# independent and can run in parallel.
+#
+# Reference: CocoaPods — lib/cocoapods/installer/project_cache/project_cache_analyzer.rb
+
+require 'concurrent'
+require 'etc'
+
+module Pod
+  module PodGenerate
+    module Patches
+      module CacheAnalyzerPatch
+        def self.apply
+          Pod::UI.message '[cocoapods-podgenerate] Applying CacheAnalyzerPatch (parallel cache key computation)'
+          Pod::Installer::ProjectCache::ProjectCacheAnalyzer.prepend(ParallelCacheKeyComputation)
+        end
+
+        module ParallelCacheKeyComputation
+          # Override create_cache_key_mappings to parallelize MD5 computation
+          # The original iterates target_by_label sequentially, computing cache keys.
+          # Since each target is independent, we use a thread pool.
+          def create_cache_key_mappings(target_by_label)
+            UI.message '- Creating cache key mappings (parallel)' do
+              pool_size = compute_pool_size
+              pool = Concurrent::FixedThreadPool.new(pool_size)
+              mutex = Mutex.new
+              results = {}
+
+              target_by_label.each do |label, target|
+                pool.post do
+                  key = case target
+                        when PodTarget
+                          local = sandbox.local?(target.pod_name)
+                          checkout_options = sandbox.checkout_sources[target.pod_name]
+                          TargetCacheKey.from_pod_target(sandbox, target_by_label, target,
+                                                         :is_local_pod => local,
+                                                         :checkout_options => checkout_options)
+                        when AggregateTarget
+                          TargetCacheKey.from_aggregate_target(sandbox, target_by_label, target)
+                        else
+                          raise "[BUG] Unknown target type #{target}"
+                        end
+                  mutex.synchronize { results[label] = key }
+                rescue StandardError => e
+                  mutex.synchronize do
+                    Pod::UI.warn "[cocoapods-podgenerate] Cache key computation error: #{e.message}"
+                  end
+                end
+              end
+
+              pool.shutdown
+              pool.wait_for_termination
+              results
+            end
+          end
+
+          private
+
+          def compute_pool_size
+            [[Etc.nprocessors - 1, 2].max, 16].min
+          rescue NameError
+            4
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-podgenerate/patches/installer_patch.rb

@@ -1,29 +1,145 @@
 # frozen_string_literal: true
 
 # [cocoapods-podgenerate]
-# Monkey-patches PodsProjectGenerator to optimize "Generating Pods project".
+# Monkey-patches Pod::Installer and PodsProjectGenerator for step 3/4 optimizations.
 #
-# Optimizations:
-#  1. Parallelize PodTargetIntegrator integration (multiple pods at once)
-#  2. Delegate install_pod_targets to original (safe, no threading issues)
+# v0.1.1 Optimizations:
+#  1. Force-enable incremental_installation + generate_multiple_pod_projects
+#  2. Skip project generation entirely when nothing changed
+#  3. Parallelize PodTargetIntegrator integration
 #
-# Reference: CocoaPods — lib/cocoapods/installer/xcode/pods_project_generator.rb
+# v0.1.2 Optimization:
+#  4. Parallelize configure_schemes across projects
+#
+# Reference: CocoaPods — lib/cocoapods/installer.rb
+#            lib/cocoapods/installer/xcode/pods_project_generator.rb
+
+require 'concurrent'
+require 'etc'
 
 module Pod
   module PodGenerate
     module Patches
       module InstallerPatch
         def self.apply
-          Pod::UI.message '[cocoapods-podgenerate] Applying InstallerPatch (optimized integration)'
+          Pod::UI.message '[cocoapods-podgenerate] Applying InstallerPatch v3'
+          Pod::Installer.prepend(ForceIncrementalInstall)
           Pod::Installer::Xcode::PodsProjectGenerator.prepend(ParallelInstall)
         end
 
+        # ── Optimization 1: Force-enable incremental_installation ──
+        module ForceIncrementalInstall
+          def install!
+            installation_options.incremental_installation = true
+            installation_options.generate_multiple_pod_projects = true
+            super
+          end
+
+          # ── Optimization 2: Skip project generation when nothing changed ──
+          def generate_pods_project
+            stage_sandbox(sandbox, pod_targets)
+
+            cache_analysis_result = analyze_project_cache
+            ptg = cache_analysis_result.pod_targets_to_generate
+            atg = cache_analysis_result.aggregate_targets_to_generate
+
+            if ptg.empty? && (atg.nil? || atg.empty?)
+              Pod::UI.puts "[cocoapods-podgenerate] No changes — skipping project generation"
+              @generated_aggregate_targets = aggregate_targets
+              @generated_pod_targets = []
+              Pod::Installer::SandboxDirCleaner.new(sandbox, pod_targets, aggregate_targets).clean!
+              update_project_cache(cache_analysis_result,
+                Pod::Installer::Xcode::PodsProjectGenerator::InstallationResults.new({}, {}))
+              return
+            end
+
+            # Normal path
+            ptg.each do |pod_target|
+              pod_target.build_headers.implode_path!(pod_target.headers_sandbox)
+              sandbox.public_headers.implode_path!(pod_target.headers_sandbox)
+            end
+
+            create_and_save_projects(ptg, atg,
+              cache_analysis_result.build_configurations, cache_analysis_result.project_object_version)
+            Pod::Installer::SandboxDirCleaner.new(sandbox, pod_targets, aggregate_targets).clean!
+            update_project_cache(cache_analysis_result, target_installation_results)
+          end
+
+          # ── Optimization 3+4: create_and_save_projects with parallel configure_schemes ──
+          def create_and_save_projects(pod_targets_to_generate, aggregate_targets_to_generate,
+                                       build_configurations, project_object_version)
+            UI.section 'Generating Pods project' do
+              generator = create_generator(pod_targets_to_generate, aggregate_targets_to_generate,
+                                           build_configurations, project_object_version,
+                                           installation_options.generate_multiple_pod_projects)
+
+              pod_project_generation_result = generator.generate!
+              @target_installation_results = pod_project_generation_result.target_installation_results
+              @pods_project = pod_project_generation_result.project
+              @pod_target_subprojects = pod_project_generation_result.projects_by_pod_targets.keys
+              @generated_projects = ([pods_project] + pod_target_subprojects || []).compact
+              @generated_pod_targets = pod_targets_to_generate
+              @generated_aggregate_targets = aggregate_targets_to_generate || []
+              projects_by_pod_targets = pod_project_generation_result.projects_by_pod_targets
+
+              predictabilize_uuids(generated_projects) if installation_options.deterministic_uuids?
+              stabilize_target_uuids(generated_projects)
+
+              projects_writer = Pod::Installer::Xcode::PodsProjectWriter.new(sandbox, generated_projects,
+                                                             target_installation_results.pod_target_installation_results,
+                                                             installation_options)
+              projects_writer.write! do
+                run_podfile_post_install_hooks
+              end
+
+              # Parallel configure_schemes (each project is independent)
+              pods_project_pod_targets = pod_targets_to_generate - projects_by_pod_targets.values.flatten
+              all_projects_by_pod_targets = {}
+              if pods_project
+                all_projects_by_pod_targets[pods_project] = pods_project_pod_targets
+              end
+              all_projects_by_pod_targets.merge!(projects_by_pod_targets) if projects_by_pod_targets
+
+              if all_projects_by_pod_targets.size > 1
+                parallel_configure_schemes(all_projects_by_pod_targets, generator, pod_project_generation_result)
+              else
+                all_projects_by_pod_targets.each do |project, pts|
+                  generator.configure_schemes(project, pts, pod_project_generation_result)
+                end
+              end
+            end
+          end
+
+          private
+
+          def parallel_configure_schemes(projects_by_pod_targets, generator, generation_result)
+            pool_size = [[Etc.nprocessors - 1, 2].max, 16].min
+            Pod::UI.message "- Configuring schemes across #{projects_by_pod_targets.size} projects (pool: #{pool_size})"
+
+            pool = Concurrent::FixedThreadPool.new(pool_size)
+            projects_by_pod_targets.each do |project, pts|
+              pool.post do
+                generator.configure_schemes(project, pts, generation_result)
+              rescue StandardError => e
+                Pod::UI.warn "[cocoapods-podgenerate] Scheme configuration error: #{e.message}"
+              end
+            end
+            pool.shutdown
+            pool.wait_for_termination
+          rescue NameError
+            # Fallback: sequential
+            projects_by_pod_targets.each do |project, pts|
+              generator.configure_schemes(project, pts, generation_result)
+            end
+          end
+        end
+
+        # ── Optimization 3: Parallelize PodTargetIntegrator ──
         module ParallelInstall
           def install_pod_targets(project, pod_targets)
             super
           end
 
-          # Override integrate_targets to run in parallel
           def integrate_targets(pod_target_installation_results)
             pods_to_integrate = pod_target_installation_results.values.select do |result|
               target = result.target

data/lib/cocoapods-podgenerate/patches/multi_project_generator_patch.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# [cocoapods-podgenerate]
+# Monkey-patches MultiPodsProjectGenerator to parallelize pod target installation.
+#
+# v0.1.2 Optimization:
+#  1. Parallel install_all_pod_targets — each pod target's install is independent I/O
+#
+# Architecture:
+#  Instead of overriding create_pods_project (which has Ruby constant resolution issues
+#  in prepended modules for PodsProjectGenerator's inner classes), we keep the original
+#  project creation + file references sequential, and only parallelize the pod target
+#  installation step which is the heaviest I/O operation.
+#
+# Reference: CocoaPods — lib/cocoapods/installer/xcode/multi_pods_project_generator.rb
+#            lib/cocoapods/installer/xcode/pods_project_generator.rb
+
+require 'concurrent'
+require 'etc'
+
+module Pod
+  module PodGenerate
+    module Patches
+      module MultiProjectGeneratorPatch
+        def self.apply
+          Pod::UI.message '[cocoapods-podgenerate] Applying MultiProjectGeneratorPatch (parallel pod target install)'
+          Pod::Installer::Xcode::MultiPodsProjectGenerator.prepend(ParallelMultiProjectGenerator)
+        end
+
+        module ParallelMultiProjectGenerator
+          # ── Optimization: Parallel install_all_pod_targets ──
+          # Each project has independent pod targets (different xcodeproj directories),
+          # so PodTargetInstaller operations can run concurrently without locking.
+          def install_all_pod_targets(projects_by_pod_targets)
+            UI.message '- Installing Pod Targets (parallel)' do
+              pool_size = compute_pool_size
+              mutex = Mutex.new
+              all_results = {}
+
+              pool = Concurrent::FixedThreadPool.new(pool_size)
+              projects_by_pod_targets.each do |project, pts|
+                pool.post do
+                  target_results = install_pod_targets(project, pts)
+                  mutex.synchronize { all_results.merge!(target_results) }
+                rescue StandardError => e
+                  mutex.synchronize do
+                    Pod::UI.warn "[cocoapods-podgenerate] Pod target install: #{e.message}"
+                  end
+                end
+              end
+
+              pool.shutdown
+              pool.wait_for_termination
+              all_results
+            end
+          end
+
+          private
+
+          def compute_pool_size
+            [[Etc.nprocessors - 1, 2].max, 16].min
+          rescue NameError
+            4
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-podgenerate/patches/project_writer_patch.rb

@@ -1,21 +1,31 @@
 # frozen_string_literal: true
 
 # [cocoapods-podgenerate]
-# Monkey-patches PodsProjectWriter to support incremental project saves.
-# Uses project.pbxproj file for change detection via SHA256 digest.
+# Monkey-patches PodsProjectWriter to support incremental + parallel project saves.
 #
-# Reference: CocoaPods source — lib/cocoapods/installer/xcode/pods_project_generator/pods_project_writer.rb
+# v0.1.1 Optimizations:
+#  1. SHA256 digest — skip sort+save for unchanged projects
+#  2. Parallel save — multiple xcodeproj files saved in threads
+#
+# v0.1.2 Optimizations:
+#  3. Parallel cleanup_projects — empty group removal across projects
+#  4. Parallel recreate_user_schemes — scheme file creation across projects
+#
+# Reference: CocoaPods — lib/cocoapods/installer/xcode/pods_project_generator/pods_project_writer.rb
+
+require 'concurrent'
+require 'etc'
 
 module Pod
   module PodGenerate
     module Patches
       module ProjectWriterPatch
         def self.apply
-          Pod::UI.message '[cocoapods-podgenerate] Applying ProjectWriterPatch (incremental save)'
-          Pod::Installer::Xcode::PodsProjectWriter.prepend(IncrementalSave)
+          Pod::UI.message '[cocoapods-podgenerate] Applying ProjectWriterPatch v3 (incremental + parallel save + parallel write steps)'
+          Pod::Installer::Xcode::PodsProjectWriter.prepend(IncrementalAndParallelSave)
         end
 
-        module IncrementalSave
+        module IncrementalAndParallelSave
           def initialize(sandbox, projects, pod_target_installation_results, installation_options)
             super
             @project_digests = {}
@@ -24,23 +34,141 @@ module Pod
             compute_initial_digests
           end
 
+          # ── Optimizations 3+4+2: Parallel write! with parallel cleanup + schemes + save ──
+          def write!
+            # Parallel cleanup (each project is independent)
+            parallel_cleanup_projects(@projects)
+
+            # Parallel recreate_user_schemes (each project is independent)
+            parallel_recreate_user_schemes(@projects)
+
+            yield if block_given?
+
+            save_projects(@projects)
+          end
+
+          # ── Optimization 1: SHA256 skip + parallel save ──
           def save_projects(projects)
-            projects.each do |project|
+            # Filter: skip projects whose pbxproj is unchanged
+            to_save = projects.select do |project|
               if project_unchanged?(project)
                 Pod::UI.message "- Skipping unchanged project #{UI.path project.path}"
-                next
+                false
+              else
+                true
               end
+            end
+            return if to_save.empty?
+
+            # Sort each project
+            to_save.each { |p| p.sort(:groups_position => :below) if needs_sort?(p) }
 
-              project.sort(:groups_position => :below) if needs_sort?(project)
-              Pod::UI.message "- Writing Xcode project file to #{UI.path project.path}" do
-                project.save
+            # Parallel save (safe: each xcodeproj is an independent directory)
+            if to_save.size > 1
+              Pod::UI.message "- Saving #{to_save.size} projects in parallel"
+              threads = to_save.map do |project|
+                Thread.new do
+                  begin
+                    Pod::UI.message "- Writing Xcode project file to #{UI.path project.path}"
+                    project.save
+                    update_digest(project)
+                  rescue StandardError => e
+                    Pod::UI.warn "[cocoapods-podgenerate] Parallel save error: #{e.message}"
+                  end
+                end
+              end
+              threads.each(&:join)
+            else
+              Pod::UI.message "- Writing Xcode project file to #{UI.path to_save.first.path}" do
+                to_save.first.save
+                update_digest(to_save.first)
               end
-              update_digest(project)
             end
           end
 
           private
 
+          # ── Optimization 3: Parallel cleanup_projects ──
+
+          def parallel_cleanup_projects(projects)
+            pool_size = compute_pool_size
+            Pod::UI.message "- Cleaning up #{projects.size} projects (pool: #{pool_size})"
+
+            pool = Concurrent::FixedThreadPool.new(pool_size)
+            projects.each do |project|
+              pool.post do
+                cleanup_single_project(project)
+              rescue StandardError => e
+                Pod::UI.warn "[cocoapods-podgenerate] Cleanup error: #{e.message}"
+              end
+            end
+            pool.shutdown
+            pool.wait_for_termination
+          rescue NameError
+            cleanup_projects(projects)
+          end
+
+          def cleanup_single_project(project)
+            [project.pods, project.support_files_group,
+             project.development_pods, project.dependencies_group].each do |group|
+              group.remove_from_project if group.respond_to?(:empty?) && group.empty?
+            end
+          end
+
+          # ── Optimization 4: Parallel recreate_user_schemes ──
+
+          def parallel_recreate_user_schemes(projects)
+            library_product_types = [:framework, :dynamic_library, :static_library]
+
+            # Pre-build results_by_native_target once (shared read-only cache)
+            results_by_native_target = build_native_target_cache
+
+            pool_size = compute_pool_size
+            Pod::UI.message "- Recreating user schemes for #{projects.size} projects (pool: #{pool_size})"
+
+            pool = Concurrent::FixedThreadPool.new(pool_size)
+            projects.each do |project|
+              pool.post do
+                project.recreate_user_schemes(false) do |scheme, target|
+                  next unless target.respond_to?(:symbol_type)
+                  next unless library_product_types.include?(target.symbol_type)
+                  installation_result = results_by_native_target[target]
+                  next unless installation_result
+                  installation_result.test_native_targets.each do |test_native_target|
+                    scheme.add_test_target(test_native_target)
+                  end
+                end
+              rescue StandardError => e
+                Pod::UI.warn "[cocoapods-podgenerate] Scheme recreation error: #{e.message}"
+              end
+            end
+            pool.shutdown
+            pool.wait_for_termination
+          rescue NameError
+            # Fallback: sequential
+            projects.each do |project|
+              project.recreate_user_schemes(false) do |scheme, target|
+                next unless target.respond_to?(:symbol_type)
+                next unless library_product_types.include?(target.symbol_type)
+                installation_result = results_by_native_target[target]
+                next unless installation_result
+                installation_result.test_native_targets.each do |test_native_target|
+                  scheme.add_test_target(test_native_target)
+                end
+              end
+            end
+          end
+
+          def build_native_target_cache
+            cache = {}
+            @pod_target_installation_results.each do |_, result|
+              cache[result.native_target] = result if result.respond_to?(:native_target)
+            end
+            cache
+          end
+
+          # ── Digest helpers (from v0.1.1) ──
+
           def compute_initial_digests
             @projects.each do |project|
               update_digest(project)
@@ -74,7 +202,6 @@ module Pod
           def pbxproj_path(project)
             path = project.path
             return nil unless path
-            # .xcodeproj is a directory; the actual content is in project.pbxproj
             if path.to_s.end_with?('.xcodeproj')
               File.join(path.to_s, 'project.pbxproj')
             else
@@ -89,6 +216,12 @@ module Pod
           rescue StandardError
             nil
           end
+
+          def compute_pool_size
+            [[Etc.nprocessors - 1, 2].max, 16].min
+          rescue NameError
+            4
+          end
         end
       end
     end

data/lib/cocoapods-podgenerate/patches/user_integrator_patch.rb

@@ -4,39 +4,43 @@
 # Monkey-patches UserProjectIntegrator to parallelize and optimize the
 # "Integrating client project" step (step 4 of pod install).
 #
-# For projects with many user targets / aggregate targets, the integration
-# step runs serially. This patch:
+# v0.1.1:
 # 1. Parallelizes integrate_user_targets using threads
 # 2. Parallelizes save_projects using threads
-# 3. Caches user_project references to avoid redundant project parsing
+#
+# v0.1.2:
+# 3. Parallelizes warn_about_xcconfig_overrides using threads
 #
 # Reference: CocoaPods source
 #   - lib/cocoapods/installer/user_project_integrator.rb
-#   - lib/cocoapods/installer/user_project_integrator/target_integrator.rb
+
+require 'concurrent'
+require 'etc'
 
 module Pod
   module PodGenerate
     module Patches
       module UserIntegratorPatch
+        IGNORED_KEYS = %w(CODE_SIGN_IDENTITY).freeze
+        INHERITED_FLAGS = %w($(inherited) ${inherited}).freeze
+
         def self.apply
-          Pod::UI.message '[cocoapods-podgenerate] Applying UserIntegratorPatch (parallel client integration)'
+          Pod::UI.message '[cocoapods-podgenerate] Applying UserIntegratorPatch v2 (parallel client integration + xcconfig warnings)'
           Pod::Installer::UserProjectIntegrator.prepend(ParallelIntegration)
         end
 
         module ParallelIntegration
-          # Override integrate_user_targets to use parallel execution
+          # ── Optimization 1: Parallel integrate_user_targets ──
           def integrate_user_targets
             target_integrators = targets_to_integrate.sort_by(&:name).map do |target|
               Pod::Installer::UserProjectIntegrator::TargetIntegrator.new(target, :use_input_output_paths => use_input_output_paths?)
             end
 
             if target_integrators.size <= 1
-              # Single target — no need for threads
               target_integrators.each(&:integrate!)
               return
             end
 
-            # Multiple targets — integrate in parallel
             Pod::UI.message "- Integrating #{target_integrators.size} targets in parallel"
             threads = target_integrators.map do |integrator|
               Thread.new do
@@ -50,7 +54,7 @@ module Pod
             threads.each(&:join)
           end
 
-          # Override save_projects to use parallel saving
+          # ── Optimization 2: Parallel save_projects ──
           def save_projects(projects)
             projects = projects.uniq
 
@@ -65,7 +69,6 @@ module Pod
               return
             end
 
-            # Save multiple projects in parallel
             Pod::UI.message "- Saving #{projects.size} user projects in parallel"
             mutex = Mutex.new
             threads = projects.map do |project|
@@ -85,6 +88,58 @@ module Pod
             end
             threads.each(&:join)
           end
+
+          # ── Optimization 3: Parallel warn_about_xcconfig_overrides ──
+          # Overrides the original method by prepend — called automatically from integrate!
+          def warn_about_xcconfig_overrides
+            targets = targets_to_integrate
+            return if targets.empty?
+
+            if targets.size <= 1
+              warn_single_target(targets.first)
+              return
+            end
+
+            pool_size = compute_pool_size
+            Pod::UI.message "- Checking xcconfig overrides for #{targets.size} targets (pool: #{pool_size})"
+            pool = Concurrent::FixedThreadPool.new(pool_size)
+            targets.each do |aggregate_target|
+              pool.post do
+                warn_single_target(aggregate_target)
+              rescue StandardError => e
+                Pod::UI.warn "[cocoapods-podgenerate] Xcconfig warning error: #{e.message}"
+              end
+            end
+            pool.shutdown
+            pool.wait_for_termination
+          rescue NameError
+            targets.each { |t| warn_single_target(t) }
+          end
+
+          private
+
+          def warn_single_target(aggregate_target)
+            aggregate_target.user_targets.each do |user_target|
+              user_target.build_configurations.each do |config|
+                xcconfig = aggregate_target.xcconfigs[config.name]
+                next unless xcconfig
+
+                (xcconfig.to_hash.keys - UserIntegratorPatch::IGNORED_KEYS).each do |key|
+                  target_values = config.build_settings[key]
+                  if target_values &&
+                      !UserIntegratorPatch::INHERITED_FLAGS.any? { |flag| target_values.include?(flag) }
+                    print_override_warning(aggregate_target, user_target, config, key)
+                  end
+                end
+              end
+            end
+          end
+
+          def compute_pool_size
+            [[Etc.nprocessors - 1, 2].max, 16].min
+          rescue NameError
+            4
+          end
         end
       end
     end

data/lib/cocoapods-podgenerate.rb

@@ -5,6 +5,8 @@ require 'cocoapods-podgenerate/patches/project_patch'
 require 'cocoapods-podgenerate/patches/project_writer_patch'
 require 'cocoapods-podgenerate/patches/analyzer_patch'
 require 'cocoapods-podgenerate/patches/user_integrator_patch'
+require 'cocoapods-podgenerate/patches/multi_project_generator_patch'
+require 'cocoapods-podgenerate/patches/cache_analyzer_patch'
 require 'cocoapods-podgenerate/parallel/thread_pool'
 require 'cocoapods-podgenerate/parallel/batch_processor'
 require 'cocoapods-podgenerate/benchmark/profiler'
@@ -18,6 +20,8 @@ module Pod
       Pod::PodGenerate::Patches::ProjectWriterPatch.apply
       Pod::PodGenerate::Patches::AnalyzerPatch.apply
       Pod::PodGenerate::Patches::UserIntegratorPatch.apply
+      Pod::PodGenerate::Patches::MultiProjectGeneratorPatch.apply
+      Pod::PodGenerate::Patches::CacheAnalyzerPatch.apply
 
       # Install hook for profiler
       Pod::PodGenerate::Benchmark::Profiler.install
@@ -28,8 +32,6 @@ module Pod
 end
 
 # Auto-activate when loaded via `plugin` directive in Podfile
-# The :pre_install hook is set up by hooks.rb, but we also support
-# direct `plugin` activation which defers to when CocoaPods is loaded.
 if defined?(Pod::HooksManager)
   Pod::PodGenerate.activate
 else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-podgenerate
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - PodGenerate Team
@@ -81,7 +81,7 @@ dependencies:
         version: '3.0'
 description: A CocoaPods plugin that accelerates pod install for large-scale projects
   with 200+ pods by introducing parallel processing, optimized dependency analysis,
-  and incremental project generation.
+  incremental project generation, and multi-project parallel saving.
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -93,12 +93,14 @@ files:
 - lib/cocoapods-podgenerate/parallel/batch_processor.rb
 - lib/cocoapods-podgenerate/parallel/thread_pool.rb
 - lib/cocoapods-podgenerate/patches/analyzer_patch.rb
+- lib/cocoapods-podgenerate/patches/cache_analyzer_patch.rb
 - lib/cocoapods-podgenerate/patches/installer_patch.rb
+- lib/cocoapods-podgenerate/patches/multi_project_generator_patch.rb
 - lib/cocoapods-podgenerate/patches/project_patch.rb
 - lib/cocoapods-podgenerate/patches/project_writer_patch.rb
 - lib/cocoapods-podgenerate/patches/user_integrator_patch.rb
 - lib/cocoapods_plugin.rb
-homepage: https://github.com/example/cocoapods-podgenerate
+homepage: https://github.com/lengain/cocoapods-podgenerate
 licenses:
 - MIT
 metadata: {}