cocoapods-generate 1.5.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f85405e2e27e0c197fac736a0f1c3d61f47e601238737f6082aa6913512c7c
-  data.tar.gz: 2fe15ee1fd79bd155bf94140fbe0a7bfbd2f318d355c43bac59b743e42da738e
+  metadata.gz: 6a8a9087ec80789ce819fb41abc24a050e4519320fd2423f6ee2467bc59d7bb1
+  data.tar.gz: e461543cdb4cea9b93bca67fe27fe9cac78488ba582a8f045cb010e7bd6b29a2
 SHA512:
-  metadata.gz: db80754352a3a07467f11099713f58788fd1a342e54c7fd75e975b3bd73f3230980c07f271de56102a696d3e6663b29a1a21ed4efc38f8ca2bc7a5a62c06f600
-  data.tar.gz: 64c521033f329de4ad9d232ce147b33d25b885c70a020175e27e65c3ce639144d2cd27c6f864a08381b0b0d05b25488693b345b62ac641ad1a88483e70eb2fe3
+  metadata.gz: 00d45b22642ad325b63ed94dbdd853c319ea591950129a5885b178f4fa64bc1fd3bdba7fa6102ac1ad9a5970a288563095bbd1dfac153d913dd889531e7cc81c
+  data.tar.gz: b0fb113e1514f18d62bcfce34242d6ae0c91279f97a185977433cee5f7081c853f2d2221460532f4f435cb17523e4570a0f0eb79cd4031ab77881590aeb1bb4f

data/README.md

@@ -47,6 +47,7 @@ Usage:
 
 Options:
 
+    --allow-root                           Allows CocoaPods to run as root
     --silent                               Show nothing
     --verbose                              Show more debugging information
     --no-ansi                              Show output without ANSI codes
@@ -79,12 +80,18 @@ Options:
     --local-sources=SOURCE1,SOURCE2        Paths from which to find local podspecs for
                                            transitive dependencies. Multiple
                                            local-sources must be comma-delimited.
+    --platforms=ios,macos                  Limit to specific platforms. Default is all
+                                           platforms supported by the podspec.
+                                           Multiple platforms must be comma-delimited.
     --repo-update                          Force running `pod repo update` before
                                            install
     --use-default-plugins                  Whether installation should activate
                                            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
@@ -94,6 +101,8 @@ 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.
 ```
 <!-- end cli usage -->
 

data/VERSION

@@ -1 +1 @@
-1.5.0
+2.1.1

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)
@@ -86,10 +86,12 @@ module Pod
           path = dir + '.gen_config.yml'
           next unless path.file?
           Pod::Generate::Configuration.from_file(path)
-        end
+        end.compact
+
+        options.delete(:podspec_paths) if options[:podspec_paths].empty? && config_hashes.any? { |h| h.include?(:podspec_paths) }
 
         env = Generate::Configuration.from_env(ENV)
-        config_hashes.insert(-2, env)
+        config_hashes = [env] + config_hashes
         config_hashes << options
 
         configuration = config_hashes.compact.each_with_object({}) { |e, h| h.merge!(e) }

data/lib/cocoapods/generate/configuration.rb

@@ -169,7 +169,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? },
@@ -188,12 +188,23 @@ module Pod
              'SOURCE1,SOURCE2',
              ->(_) { nil },
              ->(local_sources) { Array(local_sources).flat_map { |s| s.split(',') } }
+      option :platforms, ArrayOf.new(String),
+             nil,
+             'Limit to specific platforms. Default is all platforms supported by the podspec. Multiple platforms must be comma-delimited.',
+             'ios,macos',
+             lambda { |platforms|
+               valid_platforms = Platform.all.map { |p| p.string_name.downcase }
+               valid_platforms unless (platforms - valid_platforms).empty?
+             }, # validates platforms is a subset of Platform.all
+             ->(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
 
       options.freeze
       options.each do |o|
@@ -293,12 +304,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
@@ -307,13 +319,29 @@ module Pod
         !use_libraries?
       end
 
+      # @return [String] The project name to use for generating this workspace.
+      #
+      # @param [Array<Specification>] specs
+      #        the specifications to generate project name for.
+      #
+      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? && specs.count == 1
+        project_name
+      end
+
       # @return [Array<Specification>] the podspecs found at the given paths.
       #         This method will download specs from URLs and traverse a directory's children.
       #
       # @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)
@@ -329,9 +357,9 @@ 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?('..') }
             next StandardError.new "no specs found in #{UI.path path}" if glob.empty?
-            glob.map { |f| Pod::Specification.from_file(f) }
+            glob.map { |f| Pod::Specification.from_file(f) }.sort_by(&:name)
           else
             Pod::Specification.from_file(path)
           end

data/lib/cocoapods/generate/installer.rb

@@ -9,19 +9,19 @@ module Pod
       #
       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 +37,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
 
@@ -51,7 +51,12 @@ module Pod
 
           installer = nil
           UI.section 'Installing...' do
-            configuration.pod_config.with_changes(installation_root: install_directory, podfile: podfile, lockfile: configuration.lockfile, sandbox: nil, sandbox_root: install_directory, podfile_path: podfile.defined_in_file, silent: !configuration.pod_config.verbose?, verbose: false, lockfile_path: nil) do
+            configuration.pod_config.with_changes(installation_root: install_directory, podfile: podfile,
+                                                  lockfile: configuration.lockfile, sandbox: nil,
+                                                  sandbox_root: install_directory + 'Pods',
+                                                  podfile_path: podfile.defined_in_file,
+                                                  silent: !configuration.pod_config.verbose?, verbose: false,
+                                                  lockfile_path: nil) do
               installer = ::Pod::Installer.new(configuration.pod_config.sandbox, podfile, configuration.lockfile)
               installer.use_default_plugins = configuration.use_default_plugins
               installer.install!
@@ -59,7 +64,12 @@ module Pod
           end
 
           UI.section 'Performing post-installation steps' do
-            perform_post_install_steps(open_app_project, installer)
+            should_perform_post_install = if installer.respond_to?(:generated_aggregate_targets) # CocoaPods 1.7.0
+                                            !installer.generated_aggregate_targets.empty?
+                                          else
+                                            true
+                                          end
+            perform_post_install_steps(open_app_project, installer) if should_perform_post_install
           end
 
           print_post_install_message
@@ -79,7 +89,7 @@ module Pod
       end
 
       def open_app_project(recreate: false)
-        app_project_path = install_directory.join("#{spec.name}.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
@@ -92,31 +102,47 @@ module Pod
       # @return [Xcodeproj::Project]
       #
       def create_app_project
-        app_project = open_app_project(recreate: true)
-
-        spec.available_platforms.map do |platform|
-          consumer = spec.consumer(platform)
-          target_name = "App-#{Platform.string_name(consumer.platform_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
+        app_project = open_app_project(recreate: !configuration.incremental_installation?)
+
+        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 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
-            .tap do
-              app_project.recreate_user_schemes do |scheme, target|
-                installation_result = installation_result_from_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
+
+        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
-            .each do |target|
-              Xcodeproj::XCScheme.share_scheme(app_project.path, target.name)
+          end
+          .compact.uniq.tap do
+            app_project.recreate_user_schemes do |scheme, target|
+              installation_result = installation_result_from_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
+          .each do |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)
@@ -132,8 +158,13 @@ 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)
@@ -166,10 +197,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
-            Pod::Generator::AppTargetHelper.add_app_project_import(app_project, native_app_target, pod_target, pod_target.platform.name, native_app_target.name)
           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)
+            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?
+              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
           end
 
           # Set `PRODUCT_BUNDLE_IDENTIFIER`
@@ -179,21 +218,25 @@ module Pod
 
           case native_app_target.platform_name
           when :ios
-            make_ios_app_launchable(installer, app_project, native_app_target)
+            make_ios_app_launchable(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]
+            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)
@@ -217,25 +260,22 @@ 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 + (configuration.project_name_for_specs(specs) + '.xcworkspace')
         Xcodeproj::Plist.write_to_path(
           { 'IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded' => false },
-          app_project.path.sub_ext('.xcworkspace').join('xcshareddata').tap(&:mkpath).join('WorkspaceSettings.xcsettings')
+          workspace_path.join('xcshareddata').tap(&:mkpath).join('WorkspaceSettings.xcsettings')
         )
 
         test_native_targets.each do |platform_name, test_targets|
@@ -251,7 +291,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
@@ -260,9 +300,9 @@ module Pod
         end
       end
 
-      def make_ios_app_launchable(installer, app_project, native_app_target)
+      def make_ios_app_launchable(app_project, native_app_target)
         platform_name = Platform.string_name(native_app_target.platform_name)
-        generated_source_dir = installer.sandbox.root.join('App', platform_name).tap(&:mkpath)
+        generated_source_dir = install_directory.join("App-#{platform_name}").tap(&:mkpath)
 
         # Add `LaunchScreen.storyboard`
         launch_storyboard = generated_source_dir.join('LaunchScreen.storyboard')
@@ -323,12 +363,17 @@ module Pod
         Xcodeproj::Plist.write_to_path(info_plist_contents, info_plist_path)
 
         native_app_target.build_configurations.each do |bc|
-          bc.build_settings['INFOPLIST_FILE'] = "${SRCROOT}/App/#{platform_name}/Info.plist"
+          bc.build_settings['INFOPLIST_FILE'] = "${SRCROOT}/App-#{platform_name}/Info.plist"
         end
 
-        group = app_project.main_group.find_subpath("App-#{platform_name}", true)
-        group.new_file(info_plist_path)
-        native_app_target.resources_build_phase.add_file_reference group.new_file(launch_storyboard)
+        group = group_for_platform_name(app_project, platform_name)
+        group.files.find { |f| f.display_name == 'Info.plist' } || group.new_file(info_plist_path)
+        launch_storyboard_file_ref = group.files.find { |f| f.display_name == 'LaunchScreen.storyboard' } || group.new_file(launch_storyboard)
+        native_app_target.resources_build_phase.add_file_reference(launch_storyboard_file_ref)
+      end
+
+      def group_for_platform_name(project, platform_name, should_create = true)
+        project.main_group.find_subpath("App-#{platform_name}", should_create)
       end
 
       def print_post_install_message
@@ -339,8 +384,36 @@ 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

data/lib/cocoapods/generate/podfile_generator.rb

@@ -14,26 +14,27 @@ 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)
+        dir = configuration.gen_dir_for_specs(specs)
+        project_name = configuration.project_name_for_specs(specs)
 
         Pod::Podfile.new do
-          project "#{spec.name}.xcodeproj"
-          workspace "#{spec.name}.xcworkspace"
+          project "#{project_name}.xcodeproj"
+          workspace "#{project_name}.xcworkspace"
 
           plugin 'cocoapods-generate'
 
@@ -43,7 +44,7 @@ module Pod
             plugin(*[name, options].compact)
           end
 
-          use_frameworks!(generator.configuration.use_frameworks?)
+          use_frameworks!(generator.use_frameworks_value)
 
           if (supported_swift_versions = generator.supported_swift_versions)
             supports_swift_versions(supported_swift_versions)
@@ -56,24 +57,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)
@@ -81,7 +90,7 @@ 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)
@@ -89,9 +98,12 @@ module Pod
             end
           end
 
-          # Add platform-specific concrete targets that inherit the
-          # `pod` declaration for the local pod.
-          spec.available_platforms.map(&:string_name).sort.each 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
+
+          spec_platform_names.sort.each do |platform_name|
             target "App-#{platform_name}" do
               current_target_definition.swift_version = generator.swift_version if generator.swift_version
             end
@@ -112,50 +124,59 @@ 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).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
 
-      def transitive_local_dependencies(spec, paths)
-        dependencies = spec.dependencies
-        return_list = []
-        dependencies.each do |dependency|
+      def transitive_local_dependencies(spec, paths, found_podspecs: {}, include_non_library_subspecs: true)
+        if include_non_library_subspecs
+          non_library_specs = spec.recursive_subspecs.select do |ss|
+            ss.test_specification? || (ss.respond_to?(:app_specification?) && ss.app_specification?)
+          end
+          non_library_specs.each do |subspec|
+            transitive_local_dependencies(subspec, paths, found_podspecs: found_podspecs, include_non_library_subspecs: false)
+          end
+        end
+        spec.dependencies.each do |dependency|
+          next if found_podspecs.key?(dependency)
           found_podspec_file = nil
           name = dependency.name.split('/')[0]
           paths.each do |path|
-            podspec_file = path + '/' + name + '.podspec'
+            podspec_file = File.join(path, name + '.podspec')
             next unless File.file?(podspec_file)
             found_podspec_file = podspec_file
             break
           end
           next unless found_podspec_file
-          return_list << [dependency, found_podspec_file]
-          dep_spec = Pod::Specification.from_file(found_podspec_file)
-          dep_spec.dependencies.each do |d_dep|
-            dependencies << d_dep unless dependencies.include? d_dep
-          end
+          found_podspecs[dependency] = found_podspec_file.sub(%r{\A\./}, '')
+          transitive_local_dependencies(Pod::Specification.from_file(found_podspec_file), paths, found_podspecs: found_podspecs)
         end
-        return_list
+        found_podspecs
       end
 
       # @return [Boolean]
@@ -185,6 +206,27 @@ module Pod
         end
       end
 
+      # @return [Boolean, Hash]
+      #         the value to use for `use_frameworks!` DSL directive
+      #
+      def use_frameworks_value
+        return configuration.use_frameworks? unless configuration.use_podfile?
+        use_framework_values = target_definition_list.map do |target_definition|
+          if target_definition.respond_to?(:build_type) # CocoaPods >= 1.9
+            build_type = target_definition.build_type
+            if build_type.static_library?
+              false
+            else
+              { linkage: build_type == BuildType.dynamic_framework ? :dynamic : :static }
+            end
+          else
+            target_definition.uses_frameworks?
+          end
+        end.uniq
+        raise Informative, 'Multiple use_frameworks! values detected in user Podfile.' unless use_framework_values.count == 1
+        use_framework_values.first
+      end
+
       # @return [Hash]
       #         a hash with "compilation"-related dependency options for the `pod` DSL method
       #
@@ -295,7 +337,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?
         }
 
@@ -307,6 +349,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
 
@@ -349,6 +395,7 @@ module Pod
       #
       def modular_headers?(pod_name)
         return true if configuration.use_modular_headers?
+        return false unless configuration.use_podfile?
         target_definitions_for_pod(pod_name).all? do |target_definition|
           target_definition.build_pod_as_module?(pod_name)
         end

data/lib/cocoapods_plugin.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-if Pod::VERSION >= '1.5.0'
+if Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.5.0')
   require 'cocoapods/command/gen'
 else
   Pod::UI.warn 'cocoapods-generate requires CocoaPods >= 1.5.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-generate
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Samuel Giddins
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-05-15 00:00:00.000000000 Z
+date: 2021-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocoapods-disable-podfile-validations
@@ -86,7 +86,7 @@ homepage: https://github.com/square/cocoapods-generate
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -101,8 +101,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Generates Xcode workspaces from a podspec.
 test_files: []