cocoapods-generate-minlison 1.5.0

data/lib/cocoapods/generate/installer.rb

@@ -0,0 +1,347 @@
+module Pod
+  module Generate
+    # Responsible for creating a workspace for a single specification,
+    # given a configuration and a generated podfile.
+    #
+    class Installer
+      # @return [Configuration]
+      #         the configuration to use when installing
+      #
+      attr_reader :configuration
+
+      # @return [Specification]
+      #         the spec whose workspace is being created
+      #
+      attr_reader :spec
+
+      # @return [Podfile]
+      #         the podfile to install
+      #
+      attr_reader :podfile
+
+      def initialize(configuration, spec, podfile)
+        @configuration = configuration
+        @spec = spec
+        @podfile = podfile
+      end
+
+      # @return [Pathname]
+      #         The directory that pods will be installed into
+      #
+      def install_directory
+        @install_directory ||= podfile.defined_in_file.dirname
+      end
+
+      # Installs the {podfile} into the {install_directory}
+      #
+      # @return [void]
+      #
+      def install!
+        UI.title "Generating #{spec.name} in #{UI.path install_directory}" do
+          clean! if configuration.clean?
+          install_directory.mkpath
+
+          UI.message 'Creating stub application' do
+            create_app_project
+          end
+
+          UI.message 'Writing Podfile' do
+            podfile.defined_in_file.open('w') { |f| f << podfile.to_yaml }
+          end
+
+          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 = ::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)
+          end
+
+          print_post_install_message
+        end
+      end
+
+      private
+
+      # Removes the {install_directory}
+      #
+      # @return [void]
+      #
+      def clean!
+        UI.message 'Cleaning gen install directory' do
+          FileUtils.rm_rf install_directory
+        end
+      end
+
+      def open_app_project(recreate: false)
+        app_project_path = install_directory.join("#{spec.name}.xcodeproj")
+        if !recreate && app_project_path.exist?
+          Xcodeproj::Project.open(app_project_path)
+        else
+          Xcodeproj::Project.new(app_project_path)
+        end
+      end
+
+      # Creates an app project that CocoaPods will integrate into
+      #
+      # @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
+        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
+            end
+            .each do |target|
+              Xcodeproj::XCScheme.share_scheme(app_project.path, target.name)
+            end
+
+        app_project.save
+      end
+
+      def deployment_target(consumer)
+        deployment_target = consumer.spec.deployment_target(consumer.platform_name)
+        if consumer.platform_name == :ios && configuration.use_frameworks?
+          minimum = Version.new('8.0')
+          deployment_target = [Version.new(deployment_target), minimum].max.to_s
+        end
+        deployment_target
+      end
+
+      def perform_post_install_steps(app_project, installer)
+        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
+
+          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)
+            groups = {}
+
+            app_host_source_dir.find do |file|
+              relative_path = file.relative_path_from(app_host_source_dir)
+
+              if file.directory?
+                groups[relative_path] =
+                  if (base_group = groups[relative_path.dirname])
+                    basename = relative_path.basename
+                    base_group.new_group(basename.to_s, basename)
+                  else
+                    app_project.new_group(native_app_target.name, relative_app_host_source_dir)
+                  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)
+          end
+
+          # Set `PRODUCT_BUNDLE_IDENTIFIER`
+          native_app_target.build_configurations.each do |bc|
+            bc.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods-generate.${PRODUCT_NAME:rfc1034identifier}'
+          end
+
+          case native_app_target.platform_name
+          when :ios
+            make_ios_app_launchable(installer, 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?
+          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)
+            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)
+        end
+
+        app_project.save
+      end
+
+      def installation_result_from_target(target)
+        return unless target.respond_to?(:symbol_type)
+        library_product_types = %i[framework dynamic_library static_library]
+        return unless library_product_types.include? target.symbol_type
+
+        results_by_native_target[target]
+      end
+
+      def remove_script_phase_from_target(native_target, script_phase_name)
+        script_phase = native_target.shell_script_build_phases.find { |bp| bp.name && bp.name.end_with?(script_phase_name) }
+        return unless script_phase.present?
+        native_target.build_phases.delete(script_phase)
+      end
+
+      def add_test_spec_schemes_to_app_scheme(installer, app_project)
+        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
+          .flat_map(&:test_native_targets)
+          .group_by(&:platform_name)
+
+        Xcodeproj::Plist.write_to_path(
+          { 'IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded' => false },
+          app_project.path.sub_ext('.xcworkspace').join('xcshareddata').tap(&:mkpath).join('WorkspaceSettings.xcsettings')
+        )
+
+        test_native_targets.each do |platform_name, test_targets|
+          app_scheme_path = Xcodeproj::XCScheme.shared_data_dir(app_project.path).join("App-#{Platform.string_name(platform_name)}.xcscheme")
+          raise "Missing app scheme for #{platform_name}: #{app_scheme_path.inspect}" unless app_scheme_path.file?
+
+          app_scheme = Xcodeproj::XCScheme.new(app_scheme_path)
+          test_action = app_scheme.test_action
+          existing_test_targets = test_action.testables.flat_map(&:buildable_references).map(&:target_name)
+
+          test_targets.sort_by(&:name).each do |target|
+            next if existing_test_targets.include?(target.name)
+
+            testable = Xcodeproj::XCScheme::TestAction::TestableReference.new(target)
+            testable.buildable_references.each do |buildable|
+              buildable.xml_element.attributes['ReferencedContainer'] = 'container:Pods.xcodeproj'
+            end
+            test_action.add_testable(testable)
+          end
+
+          app_scheme.save!
+        end
+      end
+
+      def make_ios_app_launchable(installer, 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)
+
+        # Add `LaunchScreen.storyboard`
+        launch_storyboard = generated_source_dir.join('LaunchScreen.storyboard')
+        launch_storyboard.write <<-XML.strip_heredoc
+              <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+              <document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" systemVersion="17A277" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+                <dependencies>
+                  <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+                  <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+                </dependencies>
+                <scenes>
+                  <!--View Controller-->
+                  <scene sceneID="EHf-IW-A2E">
+                    <objects>
+                      <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                        <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                          <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                          <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                          <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        </view>
+                      </viewController>
+                      <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+                    </objects>
+                    <point key="canvasLocation" x="53" y="375"/>
+                  </scene>
+                </scenes>
+              </document>
+            XML
+
+        # Add & wire `Info.plist`
+        info_plist_contents = {
+          'CFBundleDevelopmentRegion' => '$(DEVELOPMENT_LANGUAGE)',
+          'CFBundleExecutable' => '$(EXECUTABLE_NAME)',
+          'CFBundleIdentifier' => '$(PRODUCT_BUNDLE_IDENTIFIER)',
+          'CFBundleInfoDictionaryVersion' => '6.0',
+          'CFBundleName' => '$(PRODUCT_NAME)',
+          'CFBundlePackageType' => 'APPL',
+          'CFBundleShortVersionString' => '1.0',
+          'CFBundleVersion' => '1',
+          'LSRequiresIPhoneOS' => true,
+          'UILaunchStoryboardName' => 'LaunchScreen',
+          'UIRequiredDeviceCapabilities' => [
+            'armv7'
+          ],
+          'UISupportedInterfaceOrientations' => %w[
+            UIInterfaceOrientationPortrait
+            UIInterfaceOrientationLandscapeLeft
+            UIInterfaceOrientationLandscapeRight
+          ],
+          'UISupportedInterfaceOrientations~ipad' => %w[
+            UIInterfaceOrientationPortrait
+            UIInterfaceOrientationPortraitUpsideDown
+            UIInterfaceOrientationLandscapeLeft
+            UIInterfaceOrientationLandscapeRight
+          ]
+        }
+        info_plist_path = generated_source_dir.join('Info.plist')
+        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"
+        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)
+      end
+
+      def print_post_install_message
+        workspace_path = install_directory.join(podfile.workspace_path)
+
+        if configuration.auto_open?
+          configuration.pod_config.with_changes(verbose: true) do
+            Executable.execute_command 'open', [workspace_path]
+          end
+        else
+          UI.info "Open #{UI.path workspace_path} to work on #{spec.name}"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generate/podfile_generator.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module Pod
+  module Generate
+    # Generates podfiles for pod specifications given a configuration.
+    #
+    class PodfileGenerator
+      # @return [Configuration]
+      #         the configuration used when generating podfiles
+      #
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      # @return [Hash<Specification, Podfile>]
+      #         a hash of specifications to generated podfiles
+      #
+      def podfiles_by_spec
+        Hash[configuration.podspecs.map do |spec|
+          [spec, podfile_for_spec(spec)]
+        end]
+      end
+
+      # @return [Podfile] a podfile suitable for installing the given spec
+      #
+      # @param  [Specification] spec
+      #
+      def podfile_for_spec(spec)
+        generator = self
+        dir = configuration.gen_dir_for_pod(spec.name)
+
+        Pod::Podfile.new do
+          project "#{spec.name}.xcodeproj"
+          workspace "#{spec.name}.xcworkspace"
+
+          plugin 'cocoapods-generate'
+
+          install! 'cocoapods', generator.installation_options
+
+          generator.podfile_plugins.each do |name, options|
+            plugin(*[name, options].compact)
+          end
+
+          use_frameworks!(generator.configuration.use_frameworks?)
+
+          if (supported_swift_versions = generator.supported_swift_versions)
+            supports_swift_versions(supported_swift_versions)
+          end
+
+          # Explicitly set sources
+          generator.configuration.sources.each do |source_url|
+            source(source_url)
+          end
+
+          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
+
+          # 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) })
+
+            dependencies = generator
+                           .transitive_dependencies_by_pod
+                           .values_at(*pods_for_transitive_dependencies)
+                           .compact
+                           .flatten(1)
+                           .uniq
+                           .sort_by(&:name)
+                           .reject { |d| d.root_name == spec.root.name }
+
+            dependencies.each do |dependency|
+              pod_args = generator.pod_args_for_dependency(self, dependency)
+              pod(*pod_args)
+            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|
+            target "App-#{platform_name}" do
+              current_target_definition.swift_version = generator.swift_version if generator.swift_version
+            end
+          end
+
+          # this block has to come _before_ inhibit_all_warnings! / use_modular_headers!,
+          # and the local `pod` declaration
+          current_target_definition.instance_exec do
+            transitive_dependencies = children.find { |c| c.name == 'Transitive Dependencies' }
+
+            %w[use_modular_headers inhibit_warnings].each do |key|
+              value = transitive_dependencies.send(:internal_hash).delete(key)
+              next if value.blank?
+              set_hash_value(key, value)
+            end
+          end
+
+          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
+
+          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?
+          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
+          end
+        end
+      end
+      def recursive_subspecs_dependencies(spec)
+          dependencies = []
+          spec.recursive_subspecs.each do |subspec|
+            subspec.dependencies.each do |depency|
+              if ! "#{depency}".include? "#{spec.name}"
+                dependencies << depency
+              end
+            end
+          end
+          return dependencies
+      end
+      def transitive_local_dependencies(spec, paths)
+        dependencies = recursive_subspecs_dependencies(spec)
+        return_list = []
+        dependencies.each do |dependency|
+          found_podspec_file = nil
+          name = dependency.name.split('/')[0]
+          paths.each do |path|
+            podspec_file = 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
+        end
+        return_list
+      end
+
+      # @return [Boolean]
+      #         whether all warnings should be inhibited
+      #
+      def inhibit_all_warnings?
+        return false unless configuration.use_podfile?
+        target_definition_list.all? do |target_definition|
+          target_definition.send(:inhibit_warnings_hash)['all']
+        end
+      end
+
+      # @return [Boolean]
+      #         whether all pods should use modular headers
+      #
+      def use_modular_headers?
+        if configuration.use_podfile? && configuration.use_modular_headers?
+          raise Informative, 'Conflicting `use_modular_headers` option. Cannot specify both `--use-modular-headers` and `--use-podfile`.'
+        end
+
+        if configuration.use_podfile?
+          target_definition_list.all? do |target_definition|
+            target_definition.use_modular_headers_hash['all']
+          end
+        else
+          configuration.use_modular_headers?
+        end
+      end
+
+      # @return [Hash]
+      #         a hash with "compilation"-related dependency options for the `pod` DSL method
+      #
+      # @param  [String] pod_name
+      #
+      def dependency_compilation_kwargs(pod_name)
+        options = {}
+        options[:inhibit_warnings] = inhibit_warnings?(pod_name) if inhibit_warnings?(pod_name) != inhibit_all_warnings?
+        options[:modular_headers] = modular_headers?(pod_name) if modular_headers?(pod_name) != use_modular_headers?
+        options
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         the transitive dependency objects dependency upon by each pod
+      #
+      def transitive_dependencies_by_pod
+        return {} unless configuration.use_lockfile?
+        @transitive_dependencies_by_pod ||= begin
+          lda = ::Pod::Installer::Analyzer::LockingDependencyAnalyzer
+          dependency_graph = Molinillo::DependencyGraph.new
+          configuration.lockfile.dependencies.each do |dependency|
+            dependency_graph.add_vertex(dependency.name, dependency, true)
+          end
+          add_to_dependency_graph = if lda.method(:add_to_dependency_graph).parameters.size == 4 # CocoaPods < 1.6.0
+                                      ->(pod) { lda.add_to_dependency_graph(pod, [], dependency_graph, []) }
+                                    else
+                                      ->(pod) { lda.add_to_dependency_graph(pod, [], dependency_graph, [], Set.new) }
+                                    end
+          configuration.lockfile.internal_data['PODS'].each(&add_to_dependency_graph)
+
+          transitive_dependencies_by_pod = Hash.new { |hash, key| hash[key] = [] }
+          dependency_graph.each do |v|
+            transitive_dependencies_by_pod[v.name].concat v.recursive_successors.map(&:payload) << v.payload
+          end
+
+          transitive_dependencies_by_pod.each_value(&:uniq!)
+          transitive_dependencies_by_pod
+        end
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         dependencies in the podfile grouped by root name
+      #
+      def podfile_dependencies
+        return {} unless configuration.use_podfile?
+        @podfile_dependencies ||= configuration.podfile.dependencies.group_by(&:root_name).tap { |h| h.default = [] }
+      end
+
+      # @return [Hash<String,String>]
+      #         versions in the lockfile keyed by pod name
+      #
+      def lockfile_versions
+        return {} unless configuration.use_lockfile_versions?
+        @lockfile_versions ||= Hash[configuration.lockfile.pod_names.map { |name| [name, "= #{configuration.lockfile.version(name)}"] }]
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         returns the arguments that should be passed to the Podfile DSL's
+      #         `pod` method for the given podfile and dependency
+      #
+      # @param  [Podfile] podfile
+      #
+      # @param  [Dependency] dependency
+      #
+      def pod_args_for_dependency(podfile, dependency)
+        dependency = podfile_dependencies[dependency.root_name]
+                     .map { |dep| dep.dup.tap { |d| d.name = dependency.name } }
+                     .push(dependency)
+                     .reduce(&:merge)
+
+        options = dependency_compilation_kwargs(dependency.name)
+        options[:source] = dependency.podspec_repo if dependency.podspec_repo
+        options.update(dependency.external_source) if dependency.external_source
+        %i[path podspec].each do |key|
+          next unless (path = options[key])
+          options[key] = Pathname(path)
+                         .expand_path(configuration.podfile.defined_in_file.dirname)
+                         .relative_path_from(podfile.defined_in_file.dirname)
+                         .to_s
+        end
+        args = [dependency.name]
+        if dependency.external_source.nil?
+          requirements = dependency.requirement.as_list
+          if (version = lockfile_versions[dependency.name])
+            requirements << version
+          end
+          args.concat requirements.uniq
+        end
+        args << options unless options.empty?
+        args
+      end
+
+      def swift_version
+        @swift_version ||= target_definition_list.map(&:swift_version).compact.max
+      end
+
+      def supported_swift_versions
+        return unless configuration.use_podfile?
+        return if target_definition_list.empty?
+        return unless target_definition_list.first.respond_to?(:swift_version_requirements)
+        target_definition_list.reduce(nil) do |supported_swift_versions, target_definition|
+          target_swift_versions = target_definition.swift_version_requirements
+          next supported_swift_versions unless target_swift_versions
+          Array(target_swift_versions) | Array(supported_swift_versions)
+        end
+      end
+
+      def installation_options
+        installation_options = {
+          deterministic_uuids: configuration.deterministic_uuids?,
+          share_schemes_for_development_pods: configuration.share_schemes_for_development_pods?,
+          warn_for_multiple_pod_sources: configuration.warn_for_multiple_pod_sources?
+        }
+
+        if Pod::Installer::InstallationOptions.all_options.include?('generate_multiple_pod_projects')
+          installation_options[:generate_multiple_pod_projects] = configuration.generate_multiple_pod_projects?
+        end
+
+        if Pod::Installer::InstallationOptions.all_options.include?('incremental_installation')
+          installation_options[:incremental_installation] = configuration.incremental_installation?
+        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>]
+      #         a list of all target definitions to consider from the podfile
+      #
+      def target_definition_list
+        return [] unless configuration.use_podfile?
+        @target_definition_list ||= begin
+          list = configuration.podfile.target_definition_list
+          list.reject!(&:abstract?) unless list.all?(&:abstract?)
+          list
+        end
+      end
+
+      # @return [Boolean]
+      #         whether warnings should be inhibited for the given pod
+      #
+      # @param  [String] pod_name
+      #
+      def inhibit_warnings?(pod_name)
+        return false unless configuration.use_podfile?
+        target_definitions_for_pod(pod_name).all? do |target_definition|
+          target_definition.inhibits_warnings_for_pod?(pod_name)
+        end
+      end
+
+      # @return [Boolean]
+      #         whether modular headers should be enabled for the given pod
+      #
+      # @param  [String] pod_name
+      #
+      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
+      end
+
+      # @return [Podfile::TargetDefinition]
+      #
+      # @param  [String] pod_name
+      #
+      def target_definitions_for_pod(pod_name)
+        target_definitions = target_definition_list.reject { |td| td.dependencies.none? { |d| d.name == pod_name } }
+        target_definitions.empty? ? target_definition_list : target_definitions
+      end
+    end
+  end
+end