cocoapods-dykit 0.5.2 → 0.5.3

data/lib/pod/installer/xcode/pods_project_generator/pod_target_integrator.rb

@@ -0,0 +1,111 @@
+module Pod
+  class DyInstaller
+    class Xcode
+      class PodsProjectGenerator
+        # This class is responsible for integrating a pod target. This includes integrating
+        # the test targets included by each pod target.
+        #
+        class PodTargetIntegrator
+          # @return [PodTarget] the target that should be integrated.
+          #
+          attr_reader :target
+
+          # Init a new PodTargetIntegrator.
+          #
+          # @param  [PodTarget] target @see #target
+          #
+          def initialize(target)
+            @target = target
+          end
+
+          # Integrates the pod target.
+          #
+          # @return [void]
+          #
+          def integrate!
+            UI.section(integration_message) do
+              target.test_specs_by_native_target.each do |native_target, test_specs|
+                add_embed_frameworks_script_phase(native_target)
+                add_copy_resources_script_phase(native_target)
+                UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(test_specs), native_target)
+              end
+              specs = target.non_test_specs
+              UserProjectIntegrator::TargetIntegrator.create_or_update_user_script_phases(script_phases_for_specs(specs), target.native_target)
+            end
+          end
+
+          # @return [String] a string representation suitable for debugging.
+          #
+          def inspect
+            "#<#{self.class} for target `#{target.label}'>"
+          end
+
+          private
+
+          # @!group Integration steps
+          #---------------------------------------------------------------------#
+
+          # Find or create a 'Copy Pods Resources' build phase
+          #
+          # @return [void]
+          #
+          def add_copy_resources_script_phase(native_target)
+            test_type = target.test_type_for_product_type(native_target.symbol_type)
+            script_path = "${PODS_ROOT}/#{target.copy_resources_script_path_for_test_type(test_type).relative_path_from(target.sandbox.root)}"
+            resource_paths = target.all_dependent_targets.flat_map do |dependent_target|
+              include_test_spec_paths = dependent_target == target
+              dependent_target.resource_paths(include_test_spec_paths)
+            end
+            input_paths = []
+            output_paths = []
+            unless resource_paths.empty?
+              resource_paths_flattened = resource_paths.flatten.uniq
+              input_paths = [script_path, *resource_paths_flattened]
+              output_paths = UserProjectIntegrator::TargetIntegrator.resource_output_paths(resource_paths_flattened)
+            end
+            UserProjectIntegrator::TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
+            UserProjectIntegrator::TargetIntegrator.create_or_update_copy_resources_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+          end
+
+          # Find or create a 'Embed Pods Frameworks' Copy Files Build Phase
+          #
+          # @return [void]
+          #
+          def add_embed_frameworks_script_phase(native_target)
+            test_type = target.test_type_for_product_type(native_target.symbol_type)
+            script_path = "${PODS_ROOT}/#{target.embed_frameworks_script_path_for_test_type(test_type).relative_path_from(target.sandbox.root)}"
+            all_dependent_targets = target.all_dependent_targets
+            framework_paths = all_dependent_targets.flat_map do |dependent_target|
+              include_test_spec_paths = dependent_target == target
+              dependent_target.framework_paths(include_test_spec_paths)
+            end
+            input_paths = []
+            output_paths = []
+            unless framework_paths.empty?
+              input_paths = [script_path, *framework_paths.flat_map { |fw| [fw[:input_path], fw[:dsym_input_path]] }.compact]
+              output_paths = framework_paths.flat_map { |fw| [fw[:output_path], fw[:dsym_output_path]] }.compact
+            end
+            UserProjectIntegrator::TargetIntegrator.validate_input_output_path_limit(input_paths, output_paths)
+            UserProjectIntegrator::TargetIntegrator.create_or_update_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths, output_paths)
+          end
+
+          # @return [String] the message that should be displayed for the target
+          #         integration.
+          #
+          def integration_message
+            "Integrating target `#{target.name}`"
+          end
+
+          # @param [Array<Specification] specs
+          #         the specs to return script phrases from.
+          #
+          # @return [Array<Hash<Symbol=>String>] an array of all combined script phases from the specs.
+          #
+          def script_phases_for_specs(specs)
+            specs.flat_map { |spec| spec.consumer(target.platform).script_phases }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pod/installer/xcode/pods_project_generator/target_installer.rb

@@ -0,0 +1,265 @@
+module Pod
+  class DyInstaller
+    class Xcode
+      class PodsProjectGenerator
+        # Controller class responsible of creating and configuring the static
+        # library target in Pods project. It also creates the support file needed
+        # by the target.
+        #
+        class TargetInstaller
+          # @return [Sandbox] sandbox
+          #         The sandbox where the support files should be generated.
+          #
+          attr_reader :sandbox
+
+          # @return [Target] target
+          #         The library whose target needs to be generated.
+          #
+          attr_reader :target
+
+          # Initialize a new instance
+          #
+          # @param [Sandbox] sandbox @see sandbox
+          # @param [Target] target  @see target
+          #
+          def initialize(sandbox, target)
+            @sandbox = sandbox
+            @target = target
+          end
+
+          private
+
+          #-----------------------------------------------------------------------#
+
+          # @!group Installation steps
+
+          # Adds the target for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @note   The `PODS_HEADERS_SEARCH_PATHS` overrides the xcconfig.
+          #
+          # @return [void]
+          #
+          def add_target
+            product_type = target.product_type
+            name = target.label
+            platform = target.platform.name
+            language = target.uses_swift? ? :swift : :objc
+            @native_target = project.new_target(product_type, name, platform, deployment_target, nil, language)
+
+            product_name = target.product_name
+            product = @native_target.product_reference
+            product.name = product_name
+
+            target.user_build_configurations.each do |bc_name, type|
+              @native_target.add_build_configuration(bc_name, type)
+            end
+
+            @native_target.build_configurations.each do |configuration|
+              configuration.build_settings.merge!(custom_build_settings)
+            end
+
+            target.native_target = @native_target
+          end
+
+          # @return [String] The deployment target.
+          #
+          def deployment_target
+            target.platform.deployment_target.to_s
+          end
+
+          # Returns the customized build settings which are overridden in the build
+          # settings of the user target.
+          #
+          # @return [Hash{String => String}]
+          #
+          def custom_build_settings
+            settings = {}
+
+            unless target.archs.empty?
+              settings['ARCHS'] = target.archs
+            end
+
+            if target.requires_frameworks?
+              if target.static_framework?
+                settings['MACH_O_TYPE'] = 'staticlib'
+              end
+            else
+              settings.merge!('OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '')
+            end
+
+            settings
+          end
+
+          # @param [Generator] generator
+          #        the generator to use for generating the content.
+          #
+          # @param [Pathname] path
+          #        the pathname to save the content into.
+          #
+          # Saves the content the provided path unless the path exists and the contents are exactly the same.
+          #
+          # @return [Void]
+          #
+          def update_changed_file(generator, path)
+            path.dirname.mkpath
+            if path.exist?
+              generator.save_as(support_files_temp_dir)
+              unless FileUtils.identical?(support_files_temp_dir, path)
+                FileUtils.mv(support_files_temp_dir, path)
+              end
+            else
+              generator.save_as(path)
+            end
+            clean_support_files_temp_dir if support_files_temp_dir.exist?
+          end
+
+          # Creates the directory where to store the support files of the target.
+          #
+          def create_support_files_dir
+            target.support_files_dir.mkpath
+          end
+
+          # Remove temp file whose store .prefix/config/dummy file.
+          #
+          def clean_support_files_temp_dir
+            support_files_temp_dir.rmtree
+          end
+
+          # @return [String] The temp file path to store temporary files.
+          #
+          def support_files_temp_dir
+            sandbox.target_support_files_dir('generated_files_tmp')
+          end
+
+          # Creates the Info.plist file which sets public framework attributes
+          #
+          # @param  [Pathname] path
+          #         the path to save the generated Info.plist file.
+          #
+          # @param  [PBXNativeTarget] native_target
+          #         the native target to link the generated Info.plist file into.
+          #
+          # @param  [Version] version
+          #         the version to use for when generating this Info.plist file.
+          #
+          # @param  [Platform] platform
+          #         the platform to use for when generating this Info.plist file.
+          #
+          # @param  [Symbol] bundle_package_type
+          #         the CFBundlePackageType of the target this Info.plist file is for.
+          #
+          # @return [void]
+          #
+          def create_info_plist_file(path, native_target, version, platform, bundle_package_type = :fmwk)
+            UI.message "- Generating Info.plist file at #{UI.path(path)}" do
+              generator = Generator::InfoPlistFile.new(version, platform, bundle_package_type)
+              update_changed_file(generator, path)
+              add_file_to_support_group(path)
+
+              native_target.build_configurations.each do |c|
+                relative_path = path.relative_path_from(sandbox.root)
+                c.build_settings['INFOPLIST_FILE'] = relative_path.to_s
+              end
+            end
+          end
+
+          # Creates the module map file which ensures that the umbrella header is
+          # recognized with a customized path
+          #
+          # @return [void]
+          #
+          def create_module_map
+            path = target.module_map_path
+            UI.message "- Generating module map file at #{UI.path(path)}" do
+              generator = Generator::ModuleMap.new(target)
+              yield generator if block_given?
+              update_changed_file(generator, path)
+              add_file_to_support_group(path)
+
+              native_target.build_configurations.each do |c|
+                relative_path = path.relative_path_from(sandbox.root)
+                c.build_settings['MODULEMAP_FILE'] = relative_path.to_s
+              end
+            end
+          end
+
+          # Generates a header which ensures that all header files are exported
+          # in the module map
+          #
+          # @yield_param [Generator::UmbrellaHeader]
+          #              yielded once to configure the imports
+          #
+          def create_umbrella_header
+            path = target.umbrella_header_path
+            UI.message "- Generating umbrella header at #{UI.path(path)}" do
+              generator = Generator::UmbrellaHeader.new(target)
+              yield generator if block_given?
+              update_changed_file(generator, path)
+
+              # Add the file to the support group and the native target,
+              # so it will been added to the header build phase
+              file_ref = add_file_to_support_group(path)
+              native_target.add_file_references([file_ref])
+
+              acl = target.requires_frameworks? ? 'Public' : 'Project'
+              build_file = native_target.headers_build_phase.build_file(file_ref)
+              build_file.settings ||= {}
+              build_file.settings['ATTRIBUTES'] = [acl]
+            end
+          end
+
+          # Generates a dummy source file for each target so libraries that contain
+          # only categories build.
+          #
+          # @return [void]
+          #
+          def create_dummy_source
+            path = target.dummy_source_path
+            generator = Generator::DummySource.new(target.label)
+            update_changed_file(generator, path)
+            file_reference = add_file_to_support_group(path)
+            native_target.source_build_phase.add_file_reference(file_reference)
+          end
+
+          # @return [PBXNativeTarget] the target generated by the installation
+          #         process.
+          #
+          # @note   Generated by the {#add_target} step.
+          #
+          attr_reader :native_target
+
+          private
+
+          #-----------------------------------------------------------------------#
+
+          # @!group Private helpers.
+
+          # @return [Project] the Pods project of the sandbox.
+          #
+          def project
+            sandbox.project
+          end
+
+          # @return [PBXGroup] the group where the file references to the support
+          #         files should be stored.
+          #
+          attr_reader :support_files_group
+
+          # Adds a reference to the given file in the support group of this target.
+          #
+          # @param  [Pathname] path
+          #         The path of the file to which the reference should be added.
+          #
+          # @return [PBXFileReference] the file reference of the added file.
+          #
+          def add_file_to_support_group(path)
+            support_files_group.new_file(path)
+          end
+
+          #-----------------------------------------------------------------------#
+        end
+      end
+    end
+  end
+end

data/lib/pod/installer/xcode/target_validator.rb

@@ -0,0 +1,141 @@
+module Pod
+  class DyInstaller
+    class Xcode
+      # The {Xcode::TargetValidator} ensures that the pod and aggregate target
+      # configuration is valid for installation.
+      #
+      class TargetValidator
+        # @return [Array<AggregateTarget>] The aggregate targets that should be
+        #                                  validated.
+        #
+        attr_reader :aggregate_targets
+
+        # @return [Array<PodTarget>] The pod targets that should be validated.
+        #
+        attr_reader :pod_targets
+
+        # Create a new TargetValidator with aggregate and pod targets to
+        # validate.
+        #
+        # @param [Array<AggregateTarget>] aggregate_targets
+        #                                 The aggregate targets to validate.
+        #
+        # @param [Array<PodTarget>] pod_targets
+        #                           The pod targets to validate.
+        #
+        def initialize(aggregate_targets, pod_targets)
+          @aggregate_targets = aggregate_targets
+          @pod_targets = pod_targets
+        end
+
+        # Perform the validation steps for the provided aggregate and pod
+        # targets.
+        #
+        def validate!
+          verify_no_duplicate_framework_and_library_names
+          verify_no_static_framework_transitive_dependencies
+          verify_no_pods_used_with_multiple_swift_versions
+          verify_swift_pods_have_module_dependencies
+        end
+
+        private
+
+        def verify_no_duplicate_framework_and_library_names
+          aggregate_targets.each do |aggregate_target|
+            aggregate_target.user_build_configurations.keys.each do |config|
+              pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
+              file_accessors = pod_targets.flat_map(&:file_accessors)
+
+              frameworks = file_accessors.flat_map(&:vendored_frameworks).uniq.map(&:basename)
+              frameworks += pod_targets.select { |pt| pt.should_build? && pt.requires_frameworks? }.map(&:product_module_name).uniq
+              verify_no_duplicate_names(frameworks, aggregate_target.label, 'frameworks')
+
+              libraries = file_accessors.flat_map(&:vendored_libraries).uniq.map(&:basename)
+              libraries += pod_targets.select { |pt| pt.should_build? && !pt.requires_frameworks? }.map(&:product_name)
+              verify_no_duplicate_names(libraries, aggregate_target.label, 'libraries')
+            end
+          end
+        end
+
+        def verify_no_duplicate_names(names, label, type)
+          duplicates = names.map { |n| n.to_s.downcase }.group_by { |f| f }.select { |_, v| v.size > 1 }.keys
+
+          unless duplicates.empty?
+            raise Informative, "The '#{label}' target has " \
+              "#{type} with conflicting names: #{duplicates.to_sentence}."
+          end
+        end
+
+        def verify_no_static_framework_transitive_dependencies
+          aggregate_targets.each do |aggregate_target|
+            next unless aggregate_target.requires_frameworks?
+
+            aggregate_target.user_build_configurations.keys.each do |config|
+              dynamic_pod_targets = aggregate_target.pod_targets_for_build_configuration(config).reject(&:static_framework?)
+
+              dependencies = dynamic_pod_targets.select(&:should_build?).flat_map(&:dependencies)
+              depended_upon_targets = dynamic_pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
+
+              static_libs = depended_upon_targets.flat_map(&:file_accessors).flat_map(&:vendored_static_artifacts)
+              unless static_libs.empty?
+                raise Informative, "The '#{aggregate_target.label}' target has " \
+                  "transitive dependencies that include static binaries: (#{static_libs.to_sentence})"
+              end
+
+              static_framework_deps = dynamic_pod_targets.select(&:should_build?).flat_map(&:recursive_dependent_targets).select(&:static_framework?)
+              unless static_framework_deps.empty?
+                raise Informative, "The '#{aggregate_target.label}' target has " \
+                  "transitive dependencies that include static frameworks: (#{static_framework_deps.flat_map(&:name).to_sentence})"
+              end
+            end
+          end
+        end
+
+        def verify_no_pods_used_with_multiple_swift_versions
+          error_message_for_target = lambda do |target|
+            "#{target.name} (Swift #{target.swift_version})"
+          end
+          swift_pod_targets = pod_targets.select(&:uses_swift?)
+          error_messages = swift_pod_targets.map do |pod_target|
+            next unless pod_target.spec_swift_version.nil?
+            swift_target_definitions = pod_target.target_definitions.reject { |target| target.swift_version.blank? }
+            next if swift_target_definitions.empty? || swift_target_definitions.uniq(&:swift_version).count == 1
+            target_errors = swift_target_definitions.map(&error_message_for_target).join(', ')
+            "- #{pod_target.name} required by #{target_errors}"
+          end.compact
+
+          unless error_messages.empty?
+            raise Informative, 'The following pods are integrated into targets ' \
+              "that do not have the same Swift version:\n\n#{error_messages.join("\n")}"
+          end
+        end
+
+        def verify_swift_pods_have_module_dependencies
+          error_messages = []
+          pod_targets.each do |pod_target|
+            next unless pod_target.uses_swift?
+
+            non_module_dependencies = []
+            pod_target.dependent_targets.each do |dependent_target|
+              next if !dependent_target.should_build? || dependent_target.defines_module?
+              non_module_dependencies << dependent_target.name
+            end
+
+            next if non_module_dependencies.empty?
+
+            error_messages << "The Swift pod `#{pod_target.name}` depends upon #{non_module_dependencies.map { |d| "`#{d}`" }.to_sentence}, " \
+                              'which do not define modules. ' \
+                              'To opt into those targets generating module maps '\
+                              '(which is necessary to import them from Swift when building as static libraries), ' \
+                              'you may set `use_modular_headers!` globally in your Podfile, '\
+                              'or specify `:modular_headers => true` for particular dependencies.'
+          end
+          return if error_messages.empty?
+
+          raise Informative, 'The following Swift pods cannot yet be integrated '\
+                             "as static libraries:\n\n#{error_messages.join("\n\n")}"
+        end
+      end
+    end
+  end
+end