cocoapods-podgenerate 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b3c14400566dae090f4ce380901a448e6aed75b5aab2a9b83e2629c043e547
-  data.tar.gz: f8ce64ec3991bf97c28aac639a056cb566103cade356a2baf5d3fbac81083573
+  metadata.gz: aba68b23582a229140c6580a31d506a3298d8389b6946f432e6429e1fbfe5edd
+  data.tar.gz: 2cd7a8c3bf26165fcc425f00bc03a9bffd566946d58cf126ff6c0ee6e47d97aa
 SHA512:
-  metadata.gz: 2e524501b0080aab551e23973570c0057570c4a0ddf72ec20996c7a0ff0f7de623d2138edbf667e363d3fd9ad22bb40c91d17fd48091c365e1fcfa953e388a1f
-  data.tar.gz: 7e2d6b08360a4c1d22ec27f0447634293b7d69f992ab13677829d73c997c00819c4fa99f04c346766b35e7541a25d313de80aba78c7a789c08ab1ba3531490c7
+  metadata.gz: d631266d74333c37296f116a0bedb11e31989ab3a6307d531ed4c59a2a55f7f7e8e553294c87cab2eceaa22006ceda20efaa733c123566f6cdf2314b3176e42a
+  data.tar.gz: 402636b400e0db9a80b5240730063d23215ac5c58ed87c3ac044a52839eb5a4a5d15600e48a71bf1f6363de3aa85aeae6aff9c466f512f2aa49d6de9522f5621

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,83 @@
+# 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 = compute_cache_key(target, target_by_label)
+                  mutex.synchronize { results[label] = key }
+                rescue StandardError => e
+                  # Bug fix v0.1.3: compute fallback key synchronously to avoid nil
+                  # entries that would crash ProjectCacheAnalyzer#analyze downstream
+                  Pod::UI.warn "[cocoapods-podgenerate] Cache key computation error, retrying sync: #{e.message}"
+                  fallback_key = compute_cache_key(target, target_by_label)
+                  mutex.synchronize { results[label] = fallback_key }
+                end
+              end
+
+              pool.shutdown
+              pool.wait_for_termination
+              results
+            end
+          end
+
+          private
+
+          def compute_cache_key(target, target_by_label)
+            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
+          end
+
+          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

@@ -8,14 +8,21 @@
 #  2. Skip project generation entirely when nothing changed
 #  3. Parallelize PodTargetIntegrator integration
 #
+# 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 v2'
+          Pod::UI.message '[cocoapods-podgenerate] Applying InstallerPatch v3'
           Pod::Installer.prepend(ForceIncrementalInstall)
           Pod::Installer::Xcode::PodsProjectGenerator.prepend(ParallelInstall)
         end
@@ -57,6 +64,74 @@ module Pod
             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 ──

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

@@ -7,14 +7,21 @@
 #  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 v2 (incremental + parallel save)'
+          Pod::UI.message '[cocoapods-podgenerate] Applying ProjectWriterPatch v3 (incremental + parallel save + parallel write steps)'
           Pod::Installer::Xcode::PodsProjectWriter.prepend(IncrementalAndParallelSave)
         end
 
@@ -27,7 +34,20 @@ module Pod
             compute_initial_digests
           end
 
-          # ── Optimization: SHA256 skip + parallel save ──
+          # ── 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)
             # Filter: skip projects whose pbxproj is unchanged
             to_save = projects.select do |project|
@@ -68,6 +88,98 @@ module Pod
 
           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 = begin
+              Concurrent::FixedThreadPool.new(pool_size)
+            rescue NameError
+              nil
+            end
+
+            if pool
+              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
+            else
+              # Fallback: sequential (Concurrent not available)
+              projects.each { |p| cleanup_single_project(p) }
+            end
+          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 = begin
+              Concurrent::FixedThreadPool.new(pool_size)
+            rescue NameError
+              nil
+            end
+
+            if pool
+              projects.each do |project|
+                pool.post do
+                  recreate_schemes_for_project(project, library_product_types, results_by_native_target)
+                rescue StandardError => e
+                  Pod::UI.warn "[cocoapods-podgenerate] Scheme recreation error: #{e.message}"
+                end
+              end
+              pool.shutdown
+              pool.wait_for_termination
+            else
+              # Fallback: sequential (Concurrent not available)
+              projects.each do |project|
+                recreate_schemes_for_project(project, library_product_types, results_by_native_target)
+              end
+            end
+          end
+
+          def recreate_schemes_for_project(project, library_product_types, results_by_native_target)
+            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
+
+          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)
@@ -115,6 +227,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,62 @@ 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
+
+          # Per-target xcconfig override check. Runs inside a thread pool slot.
+          # NOTE: `print_override_warning` is a private method on the original
+          # UserProjectIntegrator class. Ruby allows implicit-receiver calls to
+          # private methods from prepended modules (no explicit `self.` prefix).
+          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.1
+  version: 0.1.3
 platform: ruby
 authors:
 - PodGenerate Team
@@ -93,7 +93,9 @@ 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