cocoapods-generate 1.4.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cd88f4c2670ce0ca90f7f0d797f04b55a469bfc469c8b37362c06776f85ba6e
-  data.tar.gz: 984fb36533b3d9f66cbed561f1d70caa1799844345966ba07809afbcc6a52345
+  metadata.gz: f21262cc4824565c6d34162cb6e20312ddfa2d0ff3331c7b58fac561f2432e2f
+  data.tar.gz: 72fdfa72cca275404202ddbffcf6805fa22598b1897a379b49a77586a328cb52
 SHA512:
-  metadata.gz: b9a7d8cd37b494c7cab267b360af65690b9a05639b91ad13d101fe9d16b8658d8fd84c60f4b3c7b575810d39fe8c6db80e650596b389ced553df3df5e1d70f19
-  data.tar.gz: 1734bb0083d74411e3ac6e7bcbb5ace9d38100c2284f92e697cb6ef6d17a40909e149087a6a65e8e1785cd2a8e11e2f83c2dabf58d143d167b35e0fb4f976e7f
+  metadata.gz: 523fe6d21ea621a6c3035a59c950beea558cfbaaac1dcba17ba23ee999103e195845413bbf62a400baa8d3aff031d11a7980b4e2fe5d5e315fce370726be890d
+  data.tar.gz: 2229639a9d3ef51e44aa73ec7b3347fc049421da8ed4430e40d03ac984671ea78ebb594cb027afca83b184c25c052642a7319212980f7607ebb795583c6f12b4

data/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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
@@ -62,6 +63,8 @@ Options:
                                            be used
     --use-libraries                        Whether to use libraries instead of
                                            frameworks
+    --generate-multiple-pod-projects       Whether to generate multiple Xcode projects
+    --incremental-installation             Whether to use incremental installation
     --gen-directory=PATH                   Path to generate workspaces in
     --auto-open                            Whether to automatically open the generated
                                            workspaces
@@ -69,17 +72,26 @@ Options:
                                            before generating
     --app-host-source-dir=DIR              A directory containing sources to use for
                                            the app host
-    --sources=SOURCE1,SOURCE2              The sources from which to pull dependant
+    --sources=SOURCE1,SOURCE2              The sources from which to pull dependent
                                            pods (defaults to all repos in the podfile
                                            if using the podfile, else all available
                                            repos). Can be a repo name or URL. Multiple
                                            sources must be comma-delimited.
+    --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
@@ -89,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.4.1
+2.1.0

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? },
@@ -178,16 +178,33 @@ module Pod
       # installer options
       option :sources, ArrayOf.new(String),
              'if use_podfile && podfile then ::Pod::Installer::Analyzer.new(:sandbox, podfile).sources.map(&:url) else pod_config.sources_manager.all.map(&:url) end',
-             'The sources from which to pull dependant pods (defaults to all repos in the podfile if using the podfile, else all available repos). Can be a repo name or URL. Multiple sources must be comma-delimited.',
+             'The sources from which to pull dependent pods (defaults to all repos in the podfile if using the podfile, else all available repos). Can be a repo name or URL. Multiple sources must be comma-delimited.',
              'SOURCE1,SOURCE2',
              ->(_) { nil },
              ->(sources) { Array(sources).flat_map { |s| s.split(',') } }
+      option :local_sources, ArrayOf.new(String),
+             [],
+             'Paths from which to find local podspecs for transitive dependencies. Multiple local-sources must be comma-delimited.',
+             '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|
@@ -287,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
@@ -301,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)
@@ -323,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

@@ -4,36 +4,24 @@ module Pod
     # given a configuration and a generated podfile.
     #
     class Installer
-      # A subclass of the CocoaPods installer that vends analyzer classes
-      # that skip validating podfiles
-      #
-      class InstallerNoValidatePodfile < ::Pod::Installer
-        def create_analyzer(*)
-          super.tap do |analyzer|
-            def analyzer.validate_podfile!; end
-          end
-        end
-      end
-      private_constant :InstallerNoValidatePodfile
-
       # @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
 
@@ -49,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
 
@@ -63,15 +51,25 @@ 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
-              installer = InstallerNoValidatePodfile.new(configuration.pod_config.sandbox, podfile, configuration.lockfile)
+            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!
             end
           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
@@ -91,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
@@ -104,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)
@@ -144,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)
@@ -164,16 +183,32 @@ module Pod
                   end
 
                 next
+              elsif file.to_s.end_with?('-Bridging-Header.h')
+                native_app_target.build_configurations.each do |bc|
+                  if (old_bridging_header = bc.build_settings['SWIFT_OBJC_BRIDGING_HEADER'])
+                    raise Informative, "Conflicting Swift ObjC bridging headers specified, got #{old_bridging_header} and #{relative_path}. Only one `-Bridging-Header.h` file may be specified in the app host source dir."
+                  end
+
+                  bc.build_settings['SWIFT_OBJC_BRIDGING_HEADER'] = relative_path.to_s
+                end
               end
 
               group = groups[relative_path.dirname]
               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`
@@ -183,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)
@@ -221,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|
@@ -255,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
@@ -264,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')
@@ -327,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
@@ -343,9 +384,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() {}\n"
+        end
+
+        source_file
+      end
     end
   end
 end

data/lib/cocoapods/generate/podfile_generator.rb

@@ -14,36 +14,37 @@ 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'
 
           install! 'cocoapods', generator.installation_options
 
-          generator.configuration.podfile_plugins.each do |name, options|
+          generator.podfile_plugins.each do |name, options|
             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)
@@ -54,26 +55,34 @@ module Pod
             source(source_url)
           end
 
-          self.defined_in_file = dir.join('Podfile.yaml')
+          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 }
             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,18 +124,61 @@ 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?
+          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)
+
+            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
 
-          pod spec.name, **pod_options
+          # Implement local-sources option to set up dependencies to podspecs in the local filesystem.
+          next if generator.configuration.local_sources.empty?
+          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, 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 = File.join(path, name + '.podspec')
+            next unless File.file?(podspec_file)
+            found_podspec_file = podspec_file
+            break
+          end
+          next unless found_podspec_file
+          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
+        found_podspecs
+      end
+
       # @return [Boolean]
       #         whether all warnings should be inhibited
       #
@@ -151,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
       #
@@ -261,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?
         }
 
@@ -273,9 +349,19 @@ 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
 
+      def podfile_plugins
+        configuration.podfile_plugins.merge('cocoapods-disable-podfile-validations' => { 'no_abstract_only_pods' => true }) do |_key, old_value, new_value|
+          old_value.merge(new_value)
+        end
+      end
+
       private
 
       # @return [Array<Podfile::TargetDefinition>]
@@ -309,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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-generate
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Samuel Giddins
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-04-09 00:00:00.000000000 Z
+date: 2021-01-04 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
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +73,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CODE_OF_CONDUCT.md
+- LICENSE.md
 - README.md
 - VERSION
 - lib/cocoapods/command/gen.rb
@@ -68,9 +83,10 @@ files:
 - lib/cocoapods/generate/podfile_generator.rb
 - lib/cocoapods_plugin.rb
 homepage: https://github.com/square/cocoapods-generate
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -85,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: []