cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/installer/user_project_integrator.rb

@@ -0,0 +1,280 @@
+require 'xcodeproj/workspace'
+require 'xcodeproj/project'
+
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/array/conversions'
+
+module Pod
+  class Installer
+    # The {UserProjectIntegrator} integrates the libraries generated by
+    # TargetDefinitions of the {Podfile} with their correspondent user
+    # projects.
+    #
+    class UserProjectIntegrator
+      autoload :TargetIntegrator, 'cocoapods/installer/user_project_integrator/target_integrator'
+
+      # @return [Podfile] the podfile that should be integrated with the user
+      #         projects.
+      #
+      attr_reader :podfile
+
+      # @return [Sandbox] The sandbox used for this installation.
+      #
+      attr_reader :sandbox
+
+      # @return [Pathname] the path of the installation.
+      #
+      # @todo This is only used to compute the workspace path in case that it
+      #       should be inferred by the project. If the workspace should be in
+      #       the same dir of the project, this could be removed.
+      #
+      attr_reader :installation_root
+
+      # @return [Array<AggregateTarget>] the targets represented in the Podfile.
+      #
+      attr_reader :targets
+
+      # @return [Array<AggregateTarget>] the targets that require integration. This will always be equal or a smaller
+      #         subset of #targets.
+      #
+      attr_reader :targets_to_integrate
+
+      # @return [Boolean] whether to use input/output paths for build phase scripts
+      #
+      attr_reader :use_input_output_paths
+      alias use_input_output_paths? use_input_output_paths
+
+      # Initialize a new instance
+      #
+      # @param  [Podfile] podfile @see #podfile
+      # @param  [Sandbox] sandbox @see #sandbox
+      # @param  [Pathname] installation_root @see #installation_root
+      # @param  [Array<AggregateTarget>] targets @see #targets
+      # @param  [Array<AggregateTarget>] targets_to_integrate @see #targets_to_integrate
+      # @param  [Boolean] use_input_output_paths @see #use_input_output_paths
+      #
+      def initialize(podfile, sandbox, installation_root, targets, targets_to_integrate, use_input_output_paths: true)
+        @podfile = podfile
+        @sandbox = sandbox
+        @installation_root = installation_root
+        @targets = targets
+        @targets_to_integrate = targets_to_integrate
+        @use_input_output_paths = use_input_output_paths
+      end
+
+      # Integrates the user projects associated with the {TargetDefinitions}
+      # with the Pods project and its products.
+      #
+      # @return [void]
+      #
+      def integrate!
+        create_workspace
+        deintegrated_projects = deintegrate_removed_targets
+        integrate_user_targets
+        warn_about_xcconfig_overrides
+        projects_to_save = (user_projects_to_integrate + deintegrated_projects).uniq
+        save_projects(projects_to_save)
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Integration steps
+
+      # Creates and saved the workspace containing the Pods project and the
+      # user projects, if needed.
+      #
+      # @note If the workspace already contains the projects it is not saved
+      #       to avoid Xcode from displaying the revert dialog: `Do you want to
+      #       keep the Xcode version or revert to the version on disk?`
+      #
+      # @return [void]
+      #
+      def create_workspace
+        all_projects = user_project_paths.sort.push(sandbox.project_path).uniq
+        file_references = all_projects.map do |path|
+          relative_path = path.relative_path_from(workspace_path.dirname).to_s
+          Xcodeproj::Workspace::FileReference.new(relative_path, 'group')
+        end
+
+        if workspace_path.exist?
+          workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path)
+          new_file_references = file_references - workspace.file_references
+          unless new_file_references.empty?
+            new_file_references.each { |fr| workspace << fr }
+            workspace.save_as(workspace_path)
+          end
+
+        else
+          UI.notice "Please close any current Xcode sessions and use `#{workspace_path.basename}` for this project from now on."
+          workspace = Xcodeproj::Workspace.new(*file_references)
+          workspace.save_as(workspace_path)
+        end
+      end
+
+      # Deintegrates the targets of the user projects that are no longer part of the installation.
+      #
+      # @return [Array<Xcodeproj::PBXProject>] The list of projects that were deintegrated.
+      #
+      def deintegrate_removed_targets
+        Config.instance.with_changes(:silent => true) do
+          deintegrator = Deintegrator.new
+          all_project_targets = user_projects.flat_map(&:native_targets).uniq
+          all_native_targets = targets.flat_map(&:user_targets).uniq
+          targets_to_deintegrate = all_project_targets - all_native_targets
+          targets_to_deintegrate.each do |target|
+            deintegrator.deintegrate_target(target)
+          end
+          return targets_to_deintegrate.map(&:project).select(&:dirty?).uniq
+        end
+      end
+
+      # Integrates the targets of the user projects with the libraries
+      # generated from the {Podfile}.
+      #
+      # @note   {TargetDefinition} without dependencies are skipped prevent
+      #         creating empty libraries for targets definitions which are only
+      #         wrappers for others.
+      #
+      # @return [void]
+      #
+      def integrate_user_targets
+        target_integrators = targets_to_integrate.sort_by(&:name).map do |target|
+          TargetIntegrator.new(target, :use_input_output_paths => use_input_output_paths?)
+        end
+        target_integrators.each(&:integrate!)
+      end
+
+      # Save all user projects.
+      #
+      # @param [Array<Xcodeproj::PBXProject>] projects The projects to save.
+      #
+      # @return [void]
+      #
+      def save_projects(projects)
+        projects.each do |project|
+          if project.dirty?
+            project.save
+          else
+            # There is a bug in Xcode where the process of deleting and
+            # re-creating the xcconfig files used in the build
+            # configuration cause building the user project to fail until
+            # Xcode is relaunched.
+            #
+            # Touching/saving the project causes Xcode to reload these.
+            #
+            # https://github.com/CocoaPods/CocoaPods/issues/2665
+            FileUtils.touch(project.path + 'project.pbxproj')
+          end
+        end
+      end
+
+      IGNORED_KEYS = %w(CODE_SIGN_IDENTITY).freeze
+      INHERITED_FLAGS = %w($(inherited) ${inherited}).freeze
+
+      # Checks whether the settings of the CocoaPods generated xcconfig are
+      # overridden by the build configuration of a target and prints a
+      # warning to inform the user if needed.
+      #
+      def warn_about_xcconfig_overrides
+        targets_to_integrate.each do |aggregate_target|
+          aggregate_target.user_targets.each do |user_target|
+            user_target.build_configurations.each do |config|
+              xcconfig = aggregate_target.xcconfigs[config.name]
+              if xcconfig
+                (xcconfig.to_hash.keys - IGNORED_KEYS).each do |key|
+                  target_values = config.build_settings[key]
+                  if target_values &&
+                      !INHERITED_FLAGS.any? { |flag| target_values.include?(flag) }
+                    print_override_warning(aggregate_target, user_target, config, key)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      # @!group Private Helpers
+      #-----------------------------------------------------------------------#
+
+      # @return [Pathname] the path where the workspace containing the Pods
+      #         project and the user projects should be saved.
+      #
+      def workspace_path
+        if podfile.workspace_path
+          declared_path = podfile.workspace_path
+          path_with_ext = File.extname(declared_path) == '.xcworkspace' ? declared_path : "#{declared_path}.xcworkspace"
+          podfile_dir   = File.dirname(podfile.defined_in_file || '')
+          absolute_path = File.expand_path(path_with_ext, podfile_dir)
+          Pathname.new(absolute_path)
+        elsif user_project_paths.count == 1
+          project = user_project_paths.first.basename('.xcodeproj')
+          installation_root + "#{project}.xcworkspace"
+        else
+          raise Informative, 'Could not automatically select an Xcode ' \
+            "workspace. Specify one in your Podfile like so:\n\n"       \
+            "    workspace 'path/to/Workspace.xcworkspace'\n"
+        end
+      end
+
+      # @return [Array<Xcodeproj::Project>] the projects of all the targets that require integration.
+      #
+      # @note   Empty target definitions are ignored.
+      #
+      def user_projects_to_integrate
+        targets_to_integrate.map(&:user_project).compact.uniq
+      end
+
+      # @return [Array<Xcodeproj::Project>] the projects of all the targets regardless of whether they are integrated
+      #         or not.
+      #
+      # @note   Empty target definitions are ignored.
+      #
+      def user_projects
+        targets.map(&:user_project).compact.uniq
+      end
+
+      # @return [Array<Pathname>] the paths of all the user projects from all targets regardless of whether they are
+      #         integrated or not.
+      #
+      # @note   Empty target definitions are ignored.
+      #
+      def user_project_paths
+        targets.map(&:user_project_path).compact.uniq
+      end
+
+      # Prints a warning informing the user that a build configuration of
+      # the integrated target is overriding the CocoaPods build settings.
+      #
+      # @param  [Target::AggregateTarget] aggregate_target
+      #         The umbrella target.
+      #
+      # @param  [Xcodeproj::PBXNativeTarget] user_target
+      #         The native target.
+      #
+      # @param  [Xcodeproj::XCBuildConfiguration] config
+      #         The build configuration.
+      #
+      # @param  [String] key
+      #         The key of the overridden build setting.
+      #
+      def print_override_warning(aggregate_target, user_target, config, key)
+        actions = [
+          'Use the `$(inherited)` flag, or',
+          'Remove the build settings from the target.',
+        ]
+        message = "The `#{user_target.name} [#{config.name}]` " \
+          "target overrides the `#{key}` build setting defined in " \
+          "`#{aggregate_target.xcconfig_relative_path(config.name)}'. " \
+          'This can lead to problems with the CocoaPods installation'
+        UI.warn(message, actions)
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/multi_pods_project_generator.rb

@@ -0,0 +1,82 @@
+module Pod
+  class Installer
+    class Xcode
+      # The {MultiPodsProjectGenerator} handles generation of the 'Pods/Pods.xcodeproj' and Xcode projects
+      # for every {PodTarget}. All Pod Target projects are nested under the 'Pods.xcodeproj'.
+      #
+      class MultiPodsProjectGenerator < PodsProjectGenerator
+        # Generates `Pods/Pods.xcodeproj` and all pod target subprojects.
+        #
+        # @return [PodsProjectGeneratorResult]
+        #
+        def generate!
+          # Generate container Pods.xcodeproj.
+          container_project = create_container_project(aggregate_targets, sandbox.project_path)
+
+          project_paths_by_pod_targets = pod_targets.group_by do |pod_target|
+            sandbox.pod_target_project_path(pod_target.project_name)
+          end
+          projects_by_pod_targets = Hash[project_paths_by_pod_targets.map do |project_path, pod_targets|
+            project = create_pods_project(pod_targets, project_path, container_project)
+            [project, pod_targets]
+          end]
+
+          # Note: We must call `install_file_references` on all pod targets before installing them.
+          pod_target_installation_results = install_all_pod_targets(projects_by_pod_targets)
+          aggregate_target_installation_results = install_aggregate_targets_into_project(container_project, aggregate_targets)
+          target_installation_results = InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+
+          integrate_targets(target_installation_results.pod_target_installation_results)
+          wire_target_dependencies(target_installation_results)
+          PodsProjectGeneratorResult.new(container_project, projects_by_pod_targets, target_installation_results)
+        end
+
+        private
+
+        def create_container_project(aggregate_targets, path)
+          return unless aggregate_targets
+          platforms = aggregate_targets.map(&:platform)
+          ProjectGenerator.new(sandbox, path, [], build_configurations, platforms,
+                               project_object_version, config.podfile_path).generate!
+        end
+
+        def create_pods_project(pod_targets, path, parent_project)
+          platforms = pod_targets.map(&:platform)
+          project = ProjectGenerator.new(sandbox, path, pod_targets, build_configurations, platforms,
+                                         project_object_version, false, :pod_target_subproject => true).generate!
+          # Instead of saving every subproject to disk, we can optimize this by creating a temporary folder
+          # the file reference can use so that we only have to call `save` once for all projects.
+          project.path.mkpath
+          if parent_project
+            pod_name = pod_name_from_grouping(pod_targets)
+            is_local = sandbox.local?(pod_name)
+            parent_project.add_pod_subproject(project, is_local)
+          end
+
+          install_file_references(project, pod_targets)
+          project
+        end
+
+        def install_all_pod_targets(projects_by_pod_targets)
+          UI.message '- Installing Pod Targets' do
+            projects_by_pod_targets.each_with_object({}) do |(project, pod_targets), target_installation_results|
+              target_installation_results.merge!(install_pod_targets(project, pod_targets))
+            end
+          end
+        end
+
+        def install_aggregate_targets_into_project(project, aggregate_targets)
+          return {} unless project
+          install_aggregate_targets(project, aggregate_targets)
+        end
+
+        def pod_name_from_grouping(pod_targets)
+          # The presumption here for multi pods project is that we group by `pod_name`, thus the grouping of `pod_targets`
+          # should share the same `pod_name`.
+          raise '[BUG] Expected at least 1 pod target' if pod_targets.empty?
+          pod_targets.first.pod_name
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/aggregate_target_dependency_installer.rb

@@ -0,0 +1,66 @@
+module Pod
+  class Installer
+    class Xcode
+      # Wires up the dependencies for aggregate targets from the target installation results
+      #
+      class AggregateTargetDependencyInstaller
+        require 'cocoapods/native_target_extension.rb'
+
+        # @return [Hash{String => TargetInstallationResult}] The target installation results for pod targets.
+        #
+        attr_reader :pod_target_installation_results
+
+        # @return [Hash{String => TargetInstallationResult}] The target installation results for aggregate targets.
+        #
+        attr_reader :aggregate_target_installation_results
+
+        # @return [ProjectMetadataCache] The project metadata cache.
+        #
+        attr_reader :metadata_cache
+
+        # @return [Sandbox] The sandbox used for this installation.
+        #
+        attr_reader :sandbox
+
+        # Initialize a new instance.
+        #
+        # @param [Sandbox] sandbox @see #sandbox
+        # @param [Hash{String => TargetInstallationResult}] aggregate_target_installation_results @see #aggregate_target_installation_results
+        # @param [Hash{String => TargetInstallationResult}] pod_target_installation_results @see #pod_target_installation_results
+        # @param [ProjectMetadataCache] metadata_cache @see #metadata_cache
+        #
+        def initialize(sandbox, aggregate_target_installation_results, pod_target_installation_results, metadata_cache)
+          @sandbox = sandbox
+          @aggregate_target_installation_results = aggregate_target_installation_results
+          @pod_target_installation_results = pod_target_installation_results
+          @metadata_cache = metadata_cache
+        end
+
+        def install!
+          aggregate_target_installation_results.values.each do |aggregate_target_installation_result|
+            aggregate_target = aggregate_target_installation_result.target
+            aggregate_native_target = aggregate_target_installation_result.native_target
+            project = aggregate_native_target.project
+            # Wire up dependencies that are part of inherit search paths for this aggregate target.
+            aggregate_target.search_paths_aggregate_targets.each do |search_paths_target|
+              aggregate_native_target.add_dependency(aggregate_target_installation_results[search_paths_target.name].native_target)
+            end
+            # Wire up all pod target dependencies to aggregate target.
+            aggregate_target.pod_targets.each do |pod_target|
+              if pod_target_installation_result = pod_target_installation_results[pod_target.name]
+                pod_target_native_target = pod_target_installation_result.native_target
+                aggregate_native_target.add_dependency(pod_target_native_target)
+              else
+                # Hit the cache
+                is_local = sandbox.local?(pod_target.pod_name)
+                cached_dependency = metadata_cache.target_label_by_metadata[pod_target.label]
+                project.add_cached_pod_subproject(sandbox, cached_dependency, is_local)
+                Project.add_cached_dependency(sandbox, aggregate_native_target, cached_dependency)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/xcode/pods_project_generator/aggregate_target_installer.rb

@@ -0,0 +1,192 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # Creates the targets which aggregate the Pods libraries in the Pods
+        # project and the relative support files.
+        #
+        class AggregateTargetInstaller < TargetInstaller
+          # @return [AggregateTarget] @see TargetInstaller#target
+          #
+          attr_reader :target
+
+          # Creates the target in the Pods project and the relative support files.
+          #
+          # @return [TargetInstallationResult] the result of the installation of this target.
+          #
+          def install!
+            UI.message "- Installing target `#{target.name}` #{target.platform}" do
+              native_target = add_target
+              create_support_files_dir
+              create_support_files_group
+              create_xcconfig_file(native_target)
+              if target.build_as_framework?
+                create_info_plist_file(target.info_plist_path, native_target, target.version, target.platform)
+                create_module_map(native_target)
+                create_umbrella_header(native_target)
+              elsif target.uses_swift?
+                create_module_map(native_target)
+                create_umbrella_header(native_target)
+              end
+              # Because embedded targets live in their host target, CocoaPods
+              # copies all of the embedded target's pod_targets to its host
+              # targets. Having this script for the embedded target would
+              # cause an App Store rejection because frameworks cannot be
+              # embedded in embedded targets.
+              #
+              create_embed_frameworks_script if embed_frameworks_script_required?
+              create_bridge_support_file(native_target)
+              create_copy_resources_script if target.includes_resources?
+              create_acknowledgements
+              create_dummy_source(native_target)
+              clean_support_files_temp_dir
+              TargetInstallationResult.new(target, native_target)
+            end
+          end
+
+          #-----------------------------------------------------------------------#
+
+          private
+
+          # @return [TargetDefinition] the target definition of the library.
+          #
+          def target_definition
+            target.target_definition
+          end
+
+          # Ensure that vendored static frameworks and libraries are not linked
+          # twice to the aggregate target, which shares the xcconfig of the user
+          # target.
+          #
+          def custom_build_settings
+            settings = {
+              'CODE_SIGN_IDENTITY[sdk=appletvos*]' => '',
+              'CODE_SIGN_IDENTITY[sdk=iphoneos*]'  => '',
+              'CODE_SIGN_IDENTITY[sdk=watchos*]'   => '',
+              'MACH_O_TYPE'                        => 'staticlib',
+              'OTHER_LDFLAGS'                      => '',
+              'OTHER_LIBTOOLFLAGS'                 => '',
+              'PODS_ROOT'                          => '$(SRCROOT)',
+              'PRODUCT_BUNDLE_IDENTIFIER'          => 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}',
+              'SKIP_INSTALL'                       => 'YES',
+
+              # Needed to ensure that static libraries won't try to embed the swift stdlib,
+              # since there's no where to embed in for a static library.
+              # Not necessary for dynamic frameworks either, since the aggregate targets are never shipped
+              # on their own, and are always further embedded into an app target.
+              'ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES' => 'NO',
+            }
+            super.merge(settings)
+          end
+
+          # @return [Boolean] whether this target requires an `Embed Frameworks` script phase
+          #
+          def embed_frameworks_script_required?
+            includes_dynamic_xcframeworks = target.xcframeworks_by_config.values.flatten.map(&:build_type).any?(&:dynamic_framework?)
+            (target.includes_frameworks? || includes_dynamic_xcframeworks) && !target.requires_host_target?
+          end
+
+          # Creates the group that holds the references to the support files
+          # generated by this installer.
+          #
+          # @return [void]
+          #
+          def create_support_files_group
+            parent = project.support_files_group
+            name = target.name
+            dir = target.support_files_dir
+            @support_files_group = parent.new_group(name, dir)
+          end
+
+          # Generates the contents of the xcconfig file and saves it to disk.
+          #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to link the module map file into.
+          #
+          # @return [void]
+          #
+          def create_xcconfig_file(native_target)
+            native_target.build_configurations.each do |configuration|
+              next unless target.user_build_configurations.key?(configuration.name)
+              path = target.xcconfig_path(configuration.name)
+              build_settings = target.build_settings(configuration.name)
+              update_changed_file(build_settings, path)
+              target.xcconfigs[configuration.name] = build_settings.xcconfig
+              xcconfig_file_ref = add_file_to_support_group(path)
+              configuration.base_configuration_reference = xcconfig_file_ref
+            end
+          end
+
+          # Generates the bridge support metadata if requested by the {Podfile}.
+          #
+          # @note   The bridge support metadata is added to the resources of the
+          #         target because it is needed for environments interpreted at
+          #         runtime.
+          #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to add the bridge support file into.
+          #
+          # @return [void]
+          #
+          def create_bridge_support_file(native_target)
+            if target.podfile.generate_bridge_support?
+              path = target.bridge_support_path
+              headers = native_target.headers_build_phase.files.map { |bf| sandbox.root + bf.file_ref.path }
+              generator = Generator::BridgeSupport.new(headers)
+              update_changed_file(generator, path)
+              add_file_to_support_group(path)
+            end
+          end
+
+          # Creates a script that copies the resources to the bundle of the client
+          # target.
+          #
+          # @note   The bridge support file needs to be created before the prefix
+          #         header, otherwise it will not be added to the resources script.
+          #
+          # @return [void]
+          #
+          def create_copy_resources_script
+            path = target.copy_resources_script_path
+            generator = Generator::CopyResourcesScript.new(target.resource_paths_by_config, target.platform)
+            update_changed_file(generator, path)
+            add_file_to_support_group(path)
+          end
+
+          # Creates a script that embeds the frameworks to the bundle of the client
+          # target.
+          #
+          # @note   We can't use Xcode default link libraries phase, because
+          #         we need to ensure that we only copy the frameworks which are
+          #         relevant for the current build configuration.
+          #
+          # @return [void]
+          #
+          def create_embed_frameworks_script
+            path = target.embed_frameworks_script_path
+            generator = Generator::EmbedFrameworksScript.new(target.framework_paths_by_config, target.xcframeworks_by_config)
+            update_changed_file(generator, path)
+            add_file_to_support_group(path)
+          end
+
+          # Generates the acknowledgement files (markdown and plist) for the target.
+          #
+          # @return [void]
+          #
+          def create_acknowledgements
+            basepath = target.acknowledgements_basepath
+            Generator::Acknowledgements.generators.each do |generator_class|
+              path = generator_class.path_from_basepath(basepath)
+              file_accessors = target.pod_targets.map(&:file_accessors).flatten
+              generator = generator_class.new(file_accessors)
+              update_changed_file(generator, path)
+              add_file_to_support_group(path)
+            end
+          end
+
+          #-----------------------------------------------------------------------#
+        end
+      end
+    end
+  end
+end