cocoapods-generate 2.0.1 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ff4789b445c0e00d7e00d2808dd4ed69e0d02f5e43547ef710d83bcc0dbce62
-  data.tar.gz: cc8ab4c9925c136e06706ced54b25b419327a4d9b4625bfac7e17ed02b5f58a2
+  metadata.gz: e678737eede01f12fa09ac0d4d64a23737ec7d659147d67a9e489bb64044709e
+  data.tar.gz: 82c0cf87922bed22879443ad965b8dd9795c6d0704fab11cbf2329570d4ce6ca
 SHA512:
-  metadata.gz: 3bf5669db86616bdc81af45c12d51a7a4fc10b1f7168173394290632522a5e1e4a65c2c9f100573018022fd3feaac3599ec80f853f62b24384d0f6a5f77d0c3b
-  data.tar.gz: 003a8045475b4fc18dbf57e2c4bc12e2ade7b07da9d62b129870c52984f2ba2a27ce5eec00b6e7fa4f66e1cec43b149f433265422a3c194227ace7429c0b427f
+  metadata.gz: 458d65f261c92ff4fae69b24feab9693bc2f7a63503585b8dbdfc06aafd4e006a0a25556b6dd1d70a7213cb29a9a2d4668e4da8688dc1b628008f56fd23a0110
+  data.tar.gz: 90730f6a121011ee794f4c910135b47eee34ba177e1a1af620a6a96755d5d60f3a941b41179e25fbf9b17dc99cedabf5e3a11c5a0c618411fec2586eb8832478

data/README.md

@@ -89,6 +89,9 @@ Options:
                                            default plugins
     --deterministic-uuids                  Whether installation should use
                                            deterministic UUIDs for pods projects
+    --disable-input-output-paths           Whether to disable the input & output paths
+                                           of the CocoaPods script phases (Copy
+                                           Frameworks & Copy Resources)
     --share-schemes-for-development-pods   Whether installation should share schemes
                                            for development pods
     --warn-for-multiple-pod-sources        Whether installation should warn when a pod
@@ -98,6 +101,10 @@ Options:
                                            modules, as if `use_modular_headers!` were
                                            specified. Will error if both this option
                                            and a podfile are specified
+    --single-workspace                     Whether to produce a single workspace for
+                                           all podspecs specified.
+    --xcode-version=xcode_version          The Xcode version to use for producing the
+                                           consumer sample project
 ```
 <!-- end cli usage -->
 

data/VERSION

@@ -1 +1 @@
-2.0.1
+2.2.4

data/lib/cocoapods/command/gen.rb

@@ -64,8 +64,8 @@ module Pod
         # even if there are multiple podspecs
         update_sources if configuration.repo_update?
 
-        Generate::PodfileGenerator.new(configuration).podfiles_by_spec.each do |spec, podfile|
-          Generate::Installer.new(configuration, spec, podfile).install!
+        Generate::PodfileGenerator.new(configuration).podfiles_by_specs.each do |specs, podfile|
+          Generate::Installer.new(configuration, specs, podfile).install!
         end
 
         remove_warnings(UI.warnings)

data/lib/cocoapods/generate/configuration.rb

@@ -123,6 +123,10 @@ module Pod
         value
       end
 
+      coerce_to_version = lambda do |value|
+        Pod::Version.new(value)
+      end
+
       coerce_to_pathname = lambda do |path|
         path && Pathname(path).expand_path
       end
@@ -169,7 +173,7 @@ module Pod
              ->(paths) { ('paths do not exist' unless paths.all? { |p| p.is_a?(URI) || p.exist? }) },
              ->(paths) { paths && paths.map { |path| path.to_s =~ %r{https?://} ? URI(path) : Pathname(path).expand_path } }
       option :podspecs, ArrayOf.new(Pod::Specification),
-             'self.class.podspecs_from_paths(podspec_paths)',
+             'self.class.podspecs_from_paths(podspec_paths, gen_directory)',
              nil,
              nil,
              ->(specs) { 'no podspecs found' if specs.empty? },
@@ -199,10 +203,19 @@ module Pod
              ->(platforms) { Array(platforms).flat_map { |s| s.split(',') } }
       option :repo_update, BOOLEAN, 'false', 'Force running `pod repo update` before install', nil, nil, coerce_to_bool
       option :use_default_plugins, BOOLEAN, 'false', 'Whether installation should activate default plugins', nil, nil, coerce_to_bool
-      option :deterministic_uuids, BOOLEAN, 'false', 'Whether installation should use deterministic UUIDs for pods projects', nil, nil, coerce_to_bool
-      option :share_schemes_for_development_pods, BOOLEAN, 'true', 'Whether installation should share schemes for development pods', nil, nil, coerce_to_bool
-      option :warn_for_multiple_pod_sources, BOOLEAN, 'false', 'Whether installation should warn when a pod is found in multiple sources', nil, nil, coerce_to_bool
+      option :deterministic_uuids, BOOLEAN, '(use_podfile && podfile) ? podfile.installation_options.deterministic_uuids : false', 'Whether installation should use deterministic UUIDs for pods projects', nil, nil, coerce_to_bool
+      option :disable_input_output_paths, BOOLEAN, '(use_podfile && podfile) ? podfile.installation_options.disable_input_output_paths : false', 'Whether to disable the input & output paths of the CocoaPods script phases (Copy Frameworks & Copy Resources)', nil, nil, coerce_to_bool
+      option :share_schemes_for_development_pods, [TrueClass, FalseClass, Array], '(use_podfile && podfile) ? podfile.installation_options.share_schemes_for_development_pods : true', 'Whether installation should share schemes for development pods', nil, nil
+      option :warn_for_multiple_pod_sources, BOOLEAN, '(use_podfile && podfile) ? podfile.installation_options.warn_for_multiple_pod_sources : false', 'Whether installation should warn when a pod is found in multiple sources', nil, nil, coerce_to_bool
       option :use_modular_headers, BOOLEAN, 'false', 'Whether the target should be generated as a clang module, treating dependencies as modules, as if `use_modular_headers!` were specified. Will error if both this option and a podfile are specified', nil, nil, coerce_to_bool
+      option :single_workspace, BOOLEAN, 'false', 'Whether to produce a single workspace for all podspecs specified.', nil, nil, coerce_to_bool
+      option :xcode_version, Pod::Version, 'Pod::Version.new(\'9.3\')', 'The Xcode version to use for producing the consumer sample project', 'xcode_version', nil, coerce_to_version
+      option :external_source_pods, ArrayOf.new(HashOf.new(keys: [String], values: [ArrayOf.new(HashOf.new(keys: [String], values: [String]))])),
+             [],
+             nil,
+             nil,
+             nil,
+             ->(external_sources) { Array(external_sources) }
 
       options.freeze
       options.each do |o|
@@ -302,12 +315,13 @@ module Pod
         end << ' }'
       end
 
-      # @return [Pathname] the directory for installation of the generated workspace
+      # @return [Pathname] the directory for installation of the generated workspace.
       #
-      # @param  [String] name the name of the pod
+      # @param  [Array<Specification>] specs The specs to get a directory name for.
       #
-      def gen_dir_for_pod(name)
-        gen_directory.join(name)
+      def gen_dir_for_specs(specs)
+        basename = specs.count == 1 ? specs.first.name : 'Workspace'
+        gen_directory.join(basename)
       end
 
       # @return [Boolean] whether gen should install with dynamic frameworks
@@ -318,14 +332,14 @@ module Pod
 
       # @return [String] The project name to use for generating this workspace.
       #
-      # @param [Specification] spec
-      #        the specification to generate project name for.
+      # @param [Array<Specification>] specs
+      #        the specifications to generate project name for.
       #
-      def project_name_for_spec(spec)
-        project_name = spec.name.dup
+      def project_name_for_specs(specs)
+        project_name = specs.count == 1 ? +specs.first.name.dup : +'Workspace'
         # When using multiple Xcode project the project name will collide with the actual .xcodeproj meant for the pod
         # that we are generating the workspace for.
-        project_name << 'Sample' if generate_multiple_pod_projects?
+        project_name << 'Sample' if generate_multiple_pod_projects? && specs.count == 1
         project_name
       end
 
@@ -335,7 +349,10 @@ module Pod
       # @param  [Array<Pathname,URI>] paths
       #         the paths to search for podspecs
       #
-      def self.podspecs_from_paths(paths)
+      # @param  [Pathname] gen_directory
+      #         the directory that the gen installation would occur into.
+      #
+      def self.podspecs_from_paths(paths, gen_directory)
         paths = [Pathname('.')] if paths.empty?
         paths.flat_map do |path|
           if path.is_a?(URI)
@@ -351,9 +368,16 @@ module Pod
                 $ERROR_INFO
               end
           elsif path.directory?
-            glob = Pathname.glob(path + '*.podspec{.json,}')
+            glob = Pathname.glob(path.expand_path + '**/*.podspec{.json,}').select { |f| f.relative_path_from(gen_directory).to_s.start_with?('..') }
+            glob.reject! { |f| File.basename(f.dirname) == 'Local Podspecs' && f.parent.parent.join('Manifest.lock').file? }
             next StandardError.new "no specs found in #{UI.path path}" if glob.empty?
-            glob.map { |f| Pod::Specification.from_file(f) }.sort_by(&:name)
+            podspecs = glob.map { |f| Pod::Specification.from_file(f) }
+            podspecs.group_by(&:name).sort_by(&:first).flat_map do |name, specs|
+              if specs.size != 1
+                Pod::UI.warn("Multiple podspecs found for pod #{name}, which one will be used is undefined:#{specs.map { |s| "\n    - #{s.defined_in_file}" }.join}")
+              end
+              specs
+            end
           else
             Pod::Specification.from_file(path)
           end

data/lib/cocoapods/generate/installer.rb

@@ -4,24 +4,40 @@ module Pod
     # given a configuration and a generated podfile.
     #
     class Installer
+      DEFAULT_XCODE_VERSION = '9.3'.freeze
+
+      XCODE_VERSION_TO_OBJECT_VERSION = {
+        '14.0' => 56,
+        '13.0' => 55,
+        '12.0' => 54,
+        '11.4' => 53,
+        '11.0' => 52,
+        '10.0' => 51,
+        '9.3' => 50,
+        '8.0' => 48,
+        '6.3' => 47,
+        '3.2' => 46,
+        '3.1' => 45
+      }.freeze
+
       # @return [Configuration]
       #         the configuration to use when installing
       #
       attr_reader :configuration
 
-      # @return [Specification]
+      # @return [Array<Specification>]
       #         the spec whose workspace is being created
       #
-      attr_reader :spec
+      attr_reader :specs
 
       # @return [Podfile]
       #         the podfile to install
       #
       attr_reader :podfile
 
-      def initialize(configuration, spec, podfile)
+      def initialize(configuration, specs, podfile)
         @configuration = configuration
-        @spec = spec
+        @specs = specs
         @podfile = podfile
       end
 
@@ -37,7 +53,7 @@ module Pod
       # @return [void]
       #
       def install!
-        UI.title "Generating #{spec.name} in #{UI.path install_directory}" do
+        UI.title "Generating workspace in #{UI.path install_directory}" do
           clean! if configuration.clean?
           install_directory.mkpath
 
@@ -89,11 +105,15 @@ module Pod
       end
 
       def open_app_project(recreate: false)
-        app_project_path = install_directory.join("#{configuration.project_name_for_spec(spec)}.xcodeproj")
+        app_project_path = install_directory.join("#{configuration.project_name_for_specs(specs)}.xcodeproj")
         if !recreate && app_project_path.exist?
           Xcodeproj::Project.open(app_project_path)
         else
-          Xcodeproj::Project.new(app_project_path)
+          version_key = XCODE_VERSION_TO_OBJECT_VERSION.keys.find do |k|
+            configuration.xcode_version >= Pod::Version.new(k)
+          end || DEFAULT_XCODE_VERSION
+          object_version = XCODE_VERSION_TO_OBJECT_VERSION[version_key]
+          Xcodeproj::Project.new(app_project_path, false, object_version)
         end
       end
 
@@ -104,27 +124,32 @@ module Pod
       def create_app_project
         app_project = open_app_project(recreate: !configuration.incremental_installation?)
 
-        spec_platforms = spec.available_platforms.flatten.reject do |platform|
-          !configuration.platforms.nil? && !configuration.platforms.include?(platform.string_name.downcase)
-        end
+        platforms_by_spec = Hash[specs.map do |spec|
+          platforms = spec.available_platforms.flatten.reject do |platform|
+            !configuration.platforms.nil? && !configuration.platforms.include?(platform.string_name.downcase)
+          end
+          [spec, platforms]
+        end]
 
-        if spec_platforms.empty?
-          Pod::Command::Gen.help! Pod::StandardError.new "No available platforms in #{spec.name}.podspec match requested platforms: #{configuration.platforms}"
+        if platforms_by_spec.values.all?(&:empty?)
+          Pod::Command::Gen.help! Pod::StandardError.new "No available platforms for podspecs #{specs.map(&:name).to_sentence} match requested platforms: #{configuration.platforms}"
         end
 
-        spec_platforms
-          .map do |platform|
-            consumer = spec.consumer(platform)
-            target_name = "App-#{Platform.string_name(consumer.platform_name)}"
-            next if app_project.targets.map(&:name).include? target_name
-            native_app_target = Pod::Generator::AppTargetHelper.add_app_target(app_project, consumer.platform_name,
-                                                                               deployment_target(consumer), target_name)
-            # Temporarily set Swift version to pass validator checks for pods which do not specify Swift version.
-            # It will then be re-set again within #perform_post_install_steps.
-            Pod::Generator::AppTargetHelper.add_swift_version(native_app_target, Pod::Validator::DEFAULT_SWIFT_VERSION)
-            native_app_target
+        platforms_by_spec
+          .flat_map do |spec, platforms|
+            platforms.map do |platform|
+              consumer = spec.consumer(platform)
+              target_name = "App-#{Platform.string_name(consumer.platform_name)}"
+              next if app_project.targets.map(&:name).include? target_name
+              native_app_target = Pod::Generator::AppTargetHelper.add_app_target(app_project, consumer.platform_name,
+                                                                                 deployment_target(consumer), target_name)
+              # Temporarily set Swift version to pass validator checks for pods which do not specify Swift version.
+              # It will then be re-set again within #perform_post_install_steps.
+              Pod::Generator::AppTargetHelper.add_swift_version(native_app_target, Pod::Validator::DEFAULT_SWIFT_VERSION)
+              native_app_target
+            end
           end
-          .compact.tap do
+          .compact.uniq.tap do
             app_project.recreate_user_schemes do |scheme, target|
               installation_result = installation_result_from_target(target)
               next unless installation_result
@@ -134,9 +159,10 @@ module Pod
             end
           end
           .each do |target|
-            Xcodeproj::XCScheme.share_scheme(app_project.path, target.name) if target
+            Xcodeproj::XCScheme.share_scheme(app_project.path.to_s, target.name) if target
           end
         app_project.save
+        app_project
       end
 
       def deployment_target(consumer)
@@ -152,14 +178,16 @@ module Pod
         app_project.native_targets.each do |native_app_target|
           remove_script_phase_from_target(native_app_target, 'Check Pods Manifest.lock')
 
-          pod_target = installer.pod_targets.find { |pt| pt.platform.name == native_app_target.platform_name && pt.pod_name == spec.name }
-          raise "Unable to find a pod target for #{native_app_target} / #{spec}" unless pod_target
+          spec_names = specs.map(&:name)
+          pod_targets = installer.pod_targets.select do |pt|
+            pt.platform.name == native_app_target.platform_name && spec_names.include?(pt.pod_name)
+          end
 
           native_app_target.source_build_phase.clear
           native_app_target.resources_build_phase.clear
 
           if (app_host_source_dir = configuration.app_host_source_dir)
-            relative_app_host_source_dir = app_host_source_dir.relative_path_from(installer.sandbox.root)
+            relative_app_host_source_dir = app_host_source_dir.relative_path_from(install_directory)
             groups = {}
 
             app_host_source_dir.find do |file|
@@ -189,22 +217,18 @@ module Pod
               source_file_ref = group.new_file(file.basename)
               native_app_target.add_file_references([source_file_ref])
             end
-          elsif Pod::Generator::AppTargetHelper.method(:add_app_project_import).arity == -5 # CocoaPods >= 1.6
-            # If we are doing incremental installation then the file might already be there.
+          else
             platform_name = Platform.string_name(native_app_target.platform_name)
             group = group_for_platform_name(app_project, platform_name)
             main_file_ref = group.files.find { |f| f.display_name == 'main.m' }
             if main_file_ref.nil?
-              Pod::Generator::AppTargetHelper.add_app_project_import(app_project, native_app_target, pod_target,
-                                                                     pod_target.platform.name, native_app_target.name)
+              source_file = create_main_source_file(app_project, pod_targets, native_app_target.name)
+              group = app_project[group.name] || app_project.new_group(group.name, group.name)
+              source_file_ref = group.new_file(source_file)
+              native_app_target.add_file_references([source_file_ref])
             else
               native_app_target.add_file_references([main_file_ref])
             end
-          else
-            Pod::Generator::AppTargetHelper.add_app_project_import(app_project, native_app_target, pod_target,
-                                                                   pod_target.platform.name,
-                                                                   pod_target.requires_frameworks?,
-                                                                   native_app_target.name)
           end
 
           # Set `PRODUCT_BUNDLE_IDENTIFIER`
@@ -212,23 +236,32 @@ module Pod
             bc.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods-generate.${PRODUCT_NAME:rfc1034identifier}'
           end
 
-          case native_app_target.platform_name
+          case native_app_target.platform_name.to_sym
           when :ios
             make_ios_app_launchable(app_project, native_app_target)
+          when :osx
+            generate_infoplist_file(app_project, native_app_target)
+          when :tvos
+            generate_infoplist_file(app_project, native_app_target)
           end
 
-          Pod::Generator::AppTargetHelper.add_swift_version(native_app_target, pod_target.swift_version) unless pod_target.swift_version.blank?
+          swift_version = pod_targets.map { |pt| Pod::Version.new(pt.swift_version) }.max.to_s
+
+          Pod::Generator::AppTargetHelper.add_swift_version(native_app_target, swift_version) unless swift_version.blank?
           if installer.pod_targets.any? { |pt| pt.spec_consumers.any? { |c| c.frameworks.include?('XCTest') } }
             Pod::Generator::AppTargetHelper.add_xctest_search_paths(native_app_target)
           end
 
-          # Share the pods xcscheme only if it exists. For pre-built vendored pods there is no xcscheme generated.
-          if installer.respond_to?(:generated_projects) # CocoaPods 1.7.0
-            installer.generated_projects.each do |project|
-              Xcodeproj::XCScheme.share_scheme(project.path, pod_target.label) if File.exist?(project.path + pod_target.label)
+          pod_targets.each do |pod_target|
+            result = installer.target_installation_results.pod_target_installation_results[pod_target.name]
+            next unless result
+            share_scheme(result.native_target.project, pod_target.label)
+            pod_target.test_specs.each do |test_spec|
+              share_scheme(result.native_target.project, pod_target.test_target_label(test_spec))
+            end
+            pod_target.app_specs.each do |app_spec|
+              share_scheme(result.native_target.project, pod_target.app_target_label(app_spec))
             end
-          elsif File.exist?(installer.pods_project.path + pod_target.label)
-            Xcodeproj::XCScheme.share_scheme(installer.pods_project.path, pod_target.label)
           end
 
           add_test_spec_schemes_to_app_scheme(installer, app_project)
@@ -252,23 +285,19 @@ module Pod
       end
 
       def add_test_spec_schemes_to_app_scheme(installer, app_project)
+        spec_root_names = Set.new(specs.map { |s| s.root.name })
+
         test_native_targets =
-          if installer.respond_to?(:target_installation_results) # CocoaPods >= 1.6
-            installer
-              .target_installation_results
-              .pod_target_installation_results
-              .values
-              .flatten(1)
-              .select { |installation_result| installation_result.target.pod_name == spec.root.name }
-          else
-            installer
-              .pod_targets
-              .select { |pod_target| pod_target.pod_name == spec.root.name }
-          end
+          installer
+          .target_installation_results
+          .pod_target_installation_results
+          .values
+          .flatten(1)
+          .select { |installation_result| spec_root_names.include?(installation_result.target.pod_name) }
           .flat_map(&:test_native_targets)
           .group_by(&:platform_name)
 
-        workspace_path = install_directory + "#{spec.name}.xcworkspace"
+        workspace_path = install_directory + (configuration.project_name_for_specs(specs) + '.xcworkspace')
         Xcodeproj::Plist.write_to_path(
           { 'IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded' => false },
           workspace_path.join('xcshareddata').tap(&:mkpath).join('WorkspaceSettings.xcsettings')
@@ -287,7 +316,7 @@ module Pod
 
             testable = Xcodeproj::XCScheme::TestAction::TestableReference.new(target)
             testable.buildable_references.each do |buildable|
-              buildable.xml_element.attributes['ReferencedContainer'] = 'container:Pods.xcodeproj'
+              buildable.xml_element.attributes['ReferencedContainer'] = "container:Pods/#{File.basename(target.project.path)}"
             end
             test_action.add_testable(testable)
           end
@@ -368,6 +397,15 @@ module Pod
         native_app_target.resources_build_phase.add_file_reference(launch_storyboard_file_ref)
       end
 
+      def generate_infoplist_file(_app_project, native_app_target)
+        # Starting in Xcode 14, there is an error when you build the macOS or
+        # tvOS app that is generated from cocoapods-generate. This implements
+        # the suggested change.
+        native_app_target.build_configurations.each do |bc|
+          bc.build_settings['GENERATE_INFOPLIST_FILE'] = 'YES'
+        end
+      end
+
       def group_for_platform_name(project, platform_name, should_create = true)
         project.main_group.find_subpath("App-#{platform_name}", should_create)
       end
@@ -380,9 +418,37 @@ module Pod
             Executable.execute_command 'open', [workspace_path]
           end
         else
-          UI.info "Open #{UI.path workspace_path} to work on #{spec.name}"
+          UI.info "Open #{UI.path workspace_path} to work on it!"
         end
       end
+
+      def share_scheme(project, scheme_name)
+        scheme = Xcodeproj::XCScheme.user_data_dir(project.path) + "#{scheme_name}.xcscheme"
+        return unless File.exist?(scheme)
+        Xcodeproj::XCScheme.share_scheme(project.path, scheme_name)
+      end
+
+      def create_main_source_file(project, pod_targets, name)
+        source_file = project.path.dirname.+("#{name}/main.m")
+        source_file.parent.mkpath
+
+        import_statements = pod_targets.map do |pod_target|
+          if pod_target.should_build? && pod_target.defines_module?
+            "@import #{pod_target.product_module_name};"
+          else
+            header_name = "#{pod_target.product_module_name}/#{pod_target.product_module_name}.h"
+            "#import <#{header_name}>" if pod_target.sandbox.public_headers.root.+(header_name).file?
+          end
+        end.compact
+
+        source_file.open('w') do |f|
+          f << import_statements.join("\n")
+          f << "\n" unless import_statements.empty?
+          f << "int main() { return 0; }\n"
+        end
+
+        source_file
+      end
     end
   end
 end

data/lib/cocoapods/generate/podfile_generator.rb

@@ -14,27 +14,28 @@ module Pod
         @configuration = configuration
       end
 
-      # @return [Hash<Specification, Podfile>]
-      #         a hash of specifications to generated podfiles
+      # @return [Hash<Array<Specification>, Podfile>] the podfiles keyed by the specs that are part of each.
       #
-      def podfiles_by_spec
+      def podfiles_by_specs
+        return { configuration.podspecs => podfile_for_specs(configuration.podspecs) } if configuration.single_workspace?
         Hash[configuration.podspecs.map do |spec|
-          [spec, podfile_for_spec(spec)]
+          [[spec], podfile_for_specs([spec])]
         end]
       end
 
       # @return [Podfile] a podfile suitable for installing the given spec
       #
-      # @param  [Specification] spec
+      # @param  [Array<Specification>] specs
       #
-      def podfile_for_spec(spec)
+      def podfile_for_specs(specs)
         generator = self
-        dir = configuration.gen_dir_for_pod(spec.name)
-        project_name = configuration.project_name_for_spec(spec)
+        dir = configuration.gen_dir_for_specs(specs)
+        project_name = configuration.project_name_for_specs(specs)
+        external_source_pods = configuration.external_source_pods
 
         Pod::Podfile.new do
           project "#{project_name}.xcodeproj"
-          workspace "#{spec.name}.xcworkspace"
+          workspace "#{project_name}.xcworkspace"
 
           plugin 'cocoapods-generate'
 
@@ -57,24 +58,32 @@ module Pod
 
           self.defined_in_file = dir.join('CocoaPods.podfile.yaml')
 
-          test_specs = spec.recursive_subspecs.select(&:test_specification?)
-          app_specs = if spec.respond_to?(:app_specification?)
-                        spec.recursive_subspecs.select(&:app_specification?)
-                      else
-                        []
-                      end
+          test_specs_by_spec = Hash[specs.map do |spec|
+            [spec, spec.recursive_subspecs.select(&:test_specification?)]
+          end]
+          app_specs_by_spec = Hash[specs.map do |spec|
+            app_specs = if spec.respond_to?(:app_specification?)
+                          spec.recursive_subspecs.select(&:app_specification?)
+                        else
+                          []
+                        end
+            [spec, app_specs]
+          end]
 
           # Stick all of the transitive dependencies in an abstract target.
           # This allows us to force CocoaPods to use the versions / sources / external sources
           # that we want.
-          # By using an abstract target,
           abstract_target 'Transitive Dependencies' do
-            pods_for_transitive_dependencies = [spec.name]
-                                               .concat(test_specs.map(&:name))
-                                               .concat(test_specs.flat_map { |ts| ts.dependencies.flat_map(&:name) })
-                                               .concat(app_specs.map(&:name))
-                                               .concat(app_specs.flat_map { |as| as.dependencies.flat_map(&:name) })
+            pods_for_transitive_dependencies = specs.flat_map do |spec|
+              [spec.name]
+                .concat(test_specs_by_spec.keys.map(&:name))
+                .concat(test_specs_by_spec.values.flatten.flat_map { |ts| ts.dependencies.flat_map(&:name) })
+                .concat(app_specs_by_spec.keys.map(&:name))
+                .concat(app_specs_by_spec.values.flatten.flat_map { |as| as.dependencies.flat_map(&:name) })
+            end
+            pods_for_transitive_dependencies.uniq!
 
+            spec_names = specs.map { |s| s.root.name }.to_set
             dependencies = generator
                            .transitive_dependencies_by_pod
                            .values_at(*pods_for_transitive_dependencies)
@@ -82,17 +91,26 @@ module Pod
                            .flatten(1)
                            .uniq
                            .sort_by(&:name)
-                           .reject { |d| d.root_name == spec.root.name }
+                           .reject { |d| spec_names.include?(d.root_name) }
 
             dependencies.each do |dependency|
-              pod_args = generator.pod_args_for_dependency(self, dependency)
+              pod_args = generator.pod_args_for_podfile_dependency(self, dependency)
               pod(*pod_args)
             end
+
+            external_source_pods.each do |hash|
+              hash.each do |name, attrs|
+                next if spec_names.include?(name)
+
+                dependency = Dependency.new(name, attrs.first.deep_symbolize_keys)
+                pod_args = generator.pod_args_for_dependency(nil, dependency)
+                pod(*pod_args)
+              end
+            end
           end
 
-          # Add platform-specific concrete targets that inherit the
-          # `pod` declaration for the local pod.
-          spec_platform_names = spec.available_platforms.map(&:string_name).flatten.each.reject do |platform_name|
+          # Add platform-specific concrete targets that inherit the `pod` declaration for the local pod.
+          spec_platform_names = specs.flat_map { |s| s.available_platforms.map(&:string_name) }.uniq.each.reject do |platform_name|
             !generator.configuration.platforms.nil? && !generator.configuration.platforms.include?(platform_name.downcase)
           end
 
@@ -117,26 +135,31 @@ module Pod
           inhibit_all_warnings! if generator.inhibit_all_warnings?
           use_modular_headers! if generator.use_modular_headers?
 
-          # This is the pod declaration for the local pod,
-          # it will be inherited by the concrete target definitions below
-          pod_options = generator.dependency_compilation_kwargs(spec.name)
-          pod_options[:path] = spec.defined_in_file.relative_path_from(dir).to_s
-          { testspecs: test_specs, appspecs: app_specs }.each do |key, specs|
-            pod_options[key] = specs.map { |s| s.name.sub(%r{^#{Regexp.escape spec.root.name}/}, '') }.sort unless specs.empty?
-          end
+          specs.each do |spec|
+            # This is the pod declaration for the local pod,
+            # it will be inherited by the concrete target definitions below
+            pod_options = generator.dependency_compilation_kwargs(spec.name)
 
-          pod spec.name, **pod_options
+            path = spec.defined_in_file.relative_path_from(dir).to_s
+            pod_options[:path] = path
+            { testspecs: test_specs_by_spec[spec], appspecs: app_specs_by_spec[spec] }.each do |key, subspecs|
+              pod_options[key] = subspecs.map { |s| s.name.sub(%r{^#{Regexp.escape spec.root.name}/}, '') }.sort unless subspecs.blank?
+            end
+            pod spec.name, **pod_options
+          end
 
           # Implement local-sources option to set up dependencies to podspecs in the local filesystem.
           next if generator.configuration.local_sources.empty?
-          generator.transitive_local_dependencies(spec, generator.configuration.local_sources).sort_by(&:first).each do |dependency, podspec_file|
-            pod_options = generator.dependency_compilation_kwargs(dependency.name)
-            pod_options[:path] = if podspec_file[0] == '/' # absolute path
-                                   podspec_file
-                                 else
-                                   '../../' + podspec_file
-                                 end
-            pod dependency.name, **pod_options
+          specs.each do |spec|
+            generator.transitive_local_dependencies(spec, generator.configuration.local_sources).sort_by(&:first).each do |dependency, podspec_file|
+              pod_options = generator.dependency_compilation_kwargs(dependency.name)
+              pod_options[:path] = if podspec_file[0] == '/' # absolute path
+                                     podspec_file
+                                   else
+                                     '../../' + podspec_file
+                                   end
+              pod dependency.name, **pod_options
+            end
           end
         end
       end
@@ -279,12 +302,23 @@ module Pod
       #
       # @param  [Dependency] dependency
       #
-      def pod_args_for_dependency(podfile, dependency)
+      def pod_args_for_podfile_dependency(podfile, dependency)
         dependency = podfile_dependencies[dependency.root_name]
                      .map { |dep| dep.dup.tap { |d| d.name = dependency.name } }
                      .push(dependency)
                      .reduce(&:merge)
+        pod_args_for_dependency(podfile, dependency)
+      end
 
+      # @return [Hash<String,Array<Dependency>>]
+      #         returns the arguments that should be passed to the Podfile DSL's
+      #         `pod` method.
+      #
+      # @param  [Podfile] podfile
+      #
+      # @param  [Dependency] dependency
+      #
+      def pod_args_for_dependency(podfile, dependency)
         options = dependency_compilation_kwargs(dependency.name)
         options[:source] = dependency.podspec_repo if dependency.podspec_repo
         options.update(dependency.external_source) if dependency.external_source
@@ -325,7 +359,7 @@ module Pod
       def installation_options
         installation_options = {
           deterministic_uuids: configuration.deterministic_uuids?,
-          share_schemes_for_development_pods: configuration.share_schemes_for_development_pods?,
+          share_schemes_for_development_pods: configuration.share_schemes_for_development_pods,
           warn_for_multiple_pod_sources: configuration.warn_for_multiple_pod_sources?
         }
 
@@ -337,6 +371,10 @@ module Pod
           installation_options[:incremental_installation] = configuration.incremental_installation?
         end
 
+        if Pod::Installer::InstallationOptions.all_options.include?('disable_input_output_paths')
+          installation_options[:disable_input_output_paths] = configuration.disable_input_output_paths
+        end
+
         installation_options
       end
 

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-generate
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.2.4
 platform: ruby
 authors:
 - Samuel Giddins
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-03 00:00:00.000000000 Z
+date: 2023-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocoapods-disable-podfile-validations
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -101,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Generates Xcode workspaces from a podspec.