cocoapods 1.3.1 → 1.4.0.beta.1

data/lib/cocoapods/installer/analyzer/pod_variant.rb

@@ -7,6 +7,10 @@ module Pod
         #
         attr_accessor :specs
 
+        # @return [Array<Specification>] the test specs for the target
+        #
+        attr_accessor :test_specs
+
         # @return [Platform] the platform
         #
         attr_accessor :platform
@@ -24,16 +28,21 @@ module Pod
 
         # Initialize a new instance from its attributes.
         #
-        # @param [Array<String>] specs       @see #specs
-        # @param [Platform] platform         @see #platform
-        # @param [Bool] requires_frameworks  @see #requires_frameworks?
+        # @param [Array<Specification>] specs      @see #specs
+        # @param [Array<Specification>] test_specs @see #test_specs
+        # @param [Platform] platform               @see #platform
+        # @param [Bool] requires_frameworks        @see #requires_frameworks?
         #
-        def initialize(specs, platform, requires_frameworks = false)
+        def initialize(specs, test_specs, platform, requires_frameworks = false)
           self.specs = specs
+          self.test_specs = test_specs
           self.platform = platform
           self.requires_frameworks = requires_frameworks
         end
 
+        # @note Test specs are intentionally not included as part of the equality for pod variants since a
+        #       pod variant should not be affected by the number of test specs included.
+        #
         # @return [Bool] whether the {PodVariant} is equal to another taking all
         #         all their attributes into account
         #

data/lib/cocoapods/installer/analyzer/target_inspector.rb

@@ -161,8 +161,8 @@ module Pod
                   "Unable to determine the platform for the `#{target_definition.name}` target."
           end
 
-          UI.warn "Automatically assigning platform #{name} with version #{deployment_target} " \
-            "on target #{target_definition.name} because no platform was specified. " \
+          UI.warn "Automatically assigning platform `#{name}` with version `#{deployment_target}` " \
+            "on target `#{target_definition.name}` because no platform was specified. " \
             "Please specify a platform for this target in your Podfile. See `#{PLATFORM_INFO_URL}`."
 
           target_definition.set_platform(name, deployment_target)

data/lib/cocoapods/installer/user_project_integrator/target_integrator.rb

@@ -9,10 +9,15 @@ module Pod
       class TargetIntegrator
         autoload :XCConfigIntegrator, 'cocoapods/installer/user_project_integrator/target_integrator/xcconfig_integrator'
 
-        # @return [String] the PACKAGE emoji to use as prefix for every build phase added to the user project
+        # @return [String] the string to use as prefix for every build phase added to the user project
         #
         BUILD_PHASE_PREFIX = '[CP] '.freeze
 
+        # @return [String] the string to use as prefix for every build phase declared by the user within a podfile
+        #         or podspec.
+        #
+        USER_BUILD_PHASE_PREFIX = '[CP-User] '.freeze
+
         # @return [String] the name of the check manifest phase
         #
         CHECK_MANIFEST_PHASE_NAME = 'Check Pods Manifest.lock'.freeze
@@ -67,7 +72,7 @@ module Pod
           # @return [void]
           #
           def add_embed_frameworks_script_phase_to_target(native_target, script_path, input_paths = [], output_paths = [])
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, EMBED_FRAMEWORK_PHASE_NAME)
+            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + EMBED_FRAMEWORK_PHASE_NAME)
             phase.shell_script = %("#{script_path}"\n)
             unless input_paths.empty?
               phase.input_paths = input_paths
@@ -108,7 +113,7 @@ module Pod
           #
           def add_copy_resources_script_phase_to_target(native_target, script_path, input_paths = [], output_paths = [])
             phase_name = COPY_PODS_RESOURCES_PHASE_NAME
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, phase_name)
+            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
             phase.shell_script = %("#{script_path}"\n)
             unless input_paths.empty?
               phase.input_paths = input_paths
@@ -132,12 +137,11 @@ module Pod
           # @return [void]
           #
           def create_or_update_build_phase(native_target, phase_name, phase_class = Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
-            prefixed_phase_name = BUILD_PHASE_PREFIX + phase_name
             build_phases = native_target.build_phases.grep(phase_class)
-            build_phases.find { |phase| phase.name && phase.name.end_with?(phase_name) }.tap { |p| p.name = prefixed_phase_name if p } ||
+            build_phases.find { |phase| phase.name && phase.name.end_with?(phase_name) }.tap { |p| p.name = phase_name if p } ||
               native_target.project.new(phase_class).tap do |phase|
-                UI.message("Adding Build Phase '#{prefixed_phase_name}' to project.") do
-                  phase.name = prefixed_phase_name
+                UI.message("Adding Build Phase '#{phase_name}' to project.") do
+                  phase.name = phase_name
                   phase.show_env_vars_in_log = '0'
                   native_target.build_phases << phase
                 end
@@ -160,6 +164,7 @@ module Pod
             remove_embed_frameworks_script_phase_from_embedded_targets
             add_copy_resources_script_phase
             add_check_manifest_lock_script_phase
+            update_target_script_phases
           end
         end
 
@@ -255,6 +260,46 @@ module Pod
           end
         end
 
+        # Updates all target script phases for the current target, including creating or updating, deleting
+        # and re-ordering.
+        #
+        # @return [void]
+        #
+        def update_target_script_phases
+          target_definition_script_phases = target.target_definition.script_phases
+          target_definition_script_phase_names = target_definition_script_phases.map { |k| k[:name] }
+          native_targets.each do |native_target|
+            # Delete script phases no longer present in the target definition.
+            native_target_script_phases = native_target.shell_script_build_phases.select { |bp| !bp.name.nil? && bp.name.start_with?(USER_BUILD_PHASE_PREFIX) }
+            native_target_script_phases.each do |script_phase|
+              script_phase_name_without_prefix = script_phase.name.sub(USER_BUILD_PHASE_PREFIX, '')
+              unless target_definition_script_phase_names.include?(script_phase_name_without_prefix)
+                native_target.build_phases.delete(script_phase)
+              end
+            end
+
+            # Create or update the ones that are expected to be.
+            target_definition_script_phases.each do |td_script_phase|
+              phase = TargetIntegrator.create_or_update_build_phase(native_target, USER_BUILD_PHASE_PREFIX + td_script_phase[:name])
+              phase.shell_script = td_script_phase[:script]
+              phase.shell_path = td_script_phase[:shell_path] if td_script_phase.key?(:shell_path)
+              phase.input_paths = td_script_phase[:input_files] if td_script_phase.key?(:input_files)
+              phase.output_paths = td_script_phase[:output_files] if td_script_phase.key?(:output_files)
+              phase.show_env_vars_in_log = td_script_phase[:show_env_vars_in_log] ? '1' : '0' if td_script_phase.key?(:show_env_vars_in_log)
+            end
+
+            # Move script phases to their correct index if the order has changed.
+            offset = native_target.build_phases.count - target_definition_script_phases.count
+            target_definition_script_phases.each_with_index do |td_script_phase, index|
+              current_index = native_target.build_phases.index do |bp|
+                bp.is_a?(Xcodeproj::Project::Object::PBXShellScriptBuildPhase) && bp.name.sub(USER_BUILD_PHASE_PREFIX, '') == td_script_phase[:name]
+              end
+              expected_index = offset + index
+              native_target.build_phases.insert(expected_index, native_target.build_phases.delete_at(current_index)) if current_index != expected_index
+            end
+          end
+        end
+
         # Adds a shell script build phase responsible for checking if the Pods
         # locked in the Pods/Manifest.lock file are in sync with the Pods defined
         # in the Podfile.lock.
@@ -267,7 +312,7 @@ module Pod
         def add_check_manifest_lock_script_phase
           phase_name = CHECK_MANIFEST_PHASE_NAME
           native_targets.each do |native_target|
-            phase = TargetIntegrator.create_or_update_build_phase(native_target, phase_name)
+            phase = TargetIntegrator.create_or_update_build_phase(native_target, BUILD_PHASE_PREFIX + phase_name)
             native_target.build_phases.unshift(phase).uniq! unless native_target.build_phases.first == phase
             phase.shell_script = <<-SH.strip_heredoc
               diff "${PODS_PODFILE_DIR_PATH}/Podfile.lock" "${PODS_ROOT}/Manifest.lock" > /dev/null

data/lib/cocoapods/installer/xcode/pods_project_generator.rb

@@ -208,12 +208,14 @@ module Pod
         #
         def set_target_dependencies
           frameworks_group = project.frameworks_group
+          test_only_pod_targets = pod_targets.dup
           aggregate_targets.each do |aggregate_target|
             is_app_extension = !(aggregate_target.user_targets.map(&:symbol_type) &
                                  [:app_extension, :watch_extension, :watch2_extension, :tv_extension, :messages_extension]).empty?
             is_app_extension ||= aggregate_target.user_targets.any? { |ut| ut.common_resolved_build_setting('APPLICATION_EXTENSION_API_ONLY') == 'YES' }
 
             aggregate_target.pod_targets.each do |pod_target|
+              test_only_pod_targets.delete(pod_target)
               configure_app_extension_api_only_for_target(aggregate_target) if is_app_extension
 
               unless pod_target.should_build?
@@ -225,8 +227,24 @@ module Pod
               aggregate_target.native_target.add_dependency(pod_target.native_target)
               configure_app_extension_api_only_for_target(pod_target) if is_app_extension
 
-              add_dependent_targets_to_native_target(pod_target.dependent_targets, pod_target.native_target, is_app_extension, pod_target.requires_frameworks?, frameworks_group)
-
+              unless pod_target.static_framework?
+                add_dependent_targets_to_native_target(pod_target.dependent_targets,
+                                                       pod_target.native_target, is_app_extension,
+                                                       pod_target.requires_frameworks?, frameworks_group)
+                add_pod_target_test_dependencies(pod_target, frameworks_group)
+              end
+            end
+          end
+          # Wire up remaining pod targets used only by tests and are not used by any aggregate target.
+          test_only_pod_targets.each do |pod_target|
+            unless pod_target.should_build?
+              add_pod_target_test_dependencies(pod_target, frameworks_group)
+              next
+            end
+            unless pod_target.static_framework?
+              add_dependent_targets_to_native_target(pod_target.dependent_targets,
+                                                     pod_target.native_target, false,
+                                                     pod_target.requires_frameworks?, frameworks_group)
               add_pod_target_test_dependencies(pod_target, frameworks_group)
             end
           end

data/lib/cocoapods/installer/xcode/pods_project_generator/file_references_installer.rb

@@ -242,7 +242,7 @@ module Pod
           end
 
           # Returns a Pathname of the nearest parent from which all the given paths descend.
-          # Converts each Pathname to a string and finds the longest common prefix
+          # Converts each Pathname to a list of path components and finds the longest common prefix
           #
           # @param  [Array<Pathname>] paths
           #         The paths to files or directories on disk. Must be absolute paths
@@ -258,10 +258,12 @@ module Pod
               path.dirname.to_s
             end
             min, max = strs.minmax
+            min = min.split('/')
+            max = max.split('/')
             idx = min.size.times { |i| break i if min[i] != max[i] }
-            result = Pathname.new(min[0...idx])
+            result = Pathname.new(min[0...idx].join('/'))
             # Don't consider "/" a common path
-            return result unless result.to_s == '/'
+            return result unless result.to_s == '' || result.to_s == '/'
           end
 
           # Computes the destination sub-directory in the sandbox

data/lib/cocoapods/installer/xcode/pods_project_generator/pod_target_installer.rb

@@ -25,7 +25,9 @@ module Pod
               create_xcconfig_file
               create_test_xcconfig_files if target.contains_test_specifications?
               if target.requires_frameworks?
-                create_info_plist_file
+                unless target.static_framework?
+                  create_info_plist_file
+                end
                 create_module_map
                 create_umbrella_header do |generator|
                   file_accessors = target.file_accessors
@@ -39,6 +41,9 @@ module Pod
                                        end
                 end
                 create_build_phase_to_symlink_header_folders
+                if target.static_framework?
+                  create_build_phase_to_move_static_framework_archive
+                end
               end
               create_prefix_header
               create_dummy_source
@@ -194,6 +199,8 @@ module Pod
                 # requires frameworks. For tests we always use the test target name as the product name
                 # irrelevant to whether we use frameworks or not.
                 configuration.build_settings['PRODUCT_NAME'] = name
+                # We must codesign iOS XCTest bundles that contain binary frameworks to allow them to be launchable in the simulator
+                configuration.build_settings['CODE_SIGNING_REQUIRED'] = 'YES' unless target.platform == :osx
               end
 
               # Test native targets also need frameworks and resources to be copied over to their xctest bundle.
@@ -219,7 +226,6 @@ module Pod
                 bundle_target.product_reference.tap do |bundle_product|
                   bundle_file_name = "#{bundle_name}.bundle"
                   bundle_product.name = bundle_file_name
-                  bundle_product.path = bundle_file_name
                 end
 
                 filter_resource_file_references(paths) do |resource_phase_refs, compile_phase_refs|
@@ -388,6 +394,22 @@ module Pod
             eos
           end
 
+          # Creates a build phase to put the static framework archive in the appropriate framework location
+          # Since Xcode does not provide template support for static library frameworks, we've built a static library
+          # of the form lib{LibraryName}.a. We need to move that to the framework location -
+          # {LibraryName}.framework/{LibraryName}.
+          #
+          # @return [void]
+          #
+          def create_build_phase_to_move_static_framework_archive
+            build_phase = native_target.new_shell_script_build_phase('Setup Static Framework Archive')
+            build_phase.shell_script = <<-eos.strip_heredoc
+          mkdir -p "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/Modules"
+          cp "${BUILT_PRODUCTS_DIR}/lib${PRODUCT_NAME}.a" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/${PRODUCT_NAME}"
+          cp "${MODULEMAP_FILE}" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/Modules/module.modulemap"
+            eos
+          end
+
           # Creates a prefix header file which imports `UIKit` or `Cocoa` according
           # to the platform of the target. This file also include any prefix header
           # content reported by the specification of the pods.

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

@@ -81,7 +81,12 @@ module Pod
             end
 
             if target.requires_frameworks?
-              settings['PRODUCT_NAME'] = target.product_module_name
+              framework_name = target.product_module_name
+              settings['PRODUCT_NAME'] = framework_name
+              if target.static_framework?
+                settings['PUBLIC_HEADERS_FOLDER_PATH'] = framework_name + '.framework' + '/Headers'
+                settings['PRIVATE_HEADERS_FOLDER_PATH'] = framework_name + '.framework' + '/PrivateHeaders'
+              end
             else
               settings.merge!('OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '')
             end

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

@@ -73,7 +73,7 @@ module Pod
             aggregate_target.user_build_configurations.keys.each do |config|
               pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
 
-              dependencies = pod_targets.select(&:should_build?).flat_map(&:dependencies)
+              dependencies = pod_targets.select(&:should_build?).reject(&:static_framework?).flat_map(&:dependencies)
               depended_upon_targets = 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)

data/lib/cocoapods/resolver.rb

@@ -12,6 +12,39 @@ module Pod
   # by target for a given Podfile.
   #
   class Resolver
+    # A small container that wraps a resolved specification for a given target definition. Additional metadata
+    # is included here such as if the specification is only used by tests.
+    #
+    class ResolverSpecification
+      # @return [Specification] the specification that was resolved
+      #
+      attr_reader :spec
+
+      # @return [Bool] whether this resolved specification is only used by tests.
+      #
+      attr_reader :used_by_tests_only
+      alias used_by_tests_only? used_by_tests_only
+
+      def initialize(spec, used_by_tests_only)
+        @spec = spec
+        @used_by_tests_only = used_by_tests_only
+      end
+
+      def name
+        spec.name
+      end
+
+      def root
+        spec.root
+      end
+
+      def ==(other)
+        self.class == other &&
+          spec == other.spec &&
+          used_by_tests_only == other.test_only
+      end
+    end
+
     include Pod::Installer::InstallationOptions::Mixin
 
     delegate_installation_options { podfile }
@@ -64,8 +97,8 @@ module Pod
 
     # Identifies the specifications that should be installed.
     #
-    # @return [Hash{TargetDefinition => Array<Specification>}] specs_by_target
-    #         the specifications that need to be installed grouped by target
+    # @return [Hash{TargetDefinition => Array<ResolverSpecification>}] resolver_specs_by_target
+    #         the resolved specifications that need to be installed grouped by target
     #         definition.
     #
     def resolve
@@ -75,28 +108,28 @@ module Pod
         end
       end
       @activated = Molinillo::Resolver.new(self, self).resolve(dependencies, locked_dependencies)
-      specs_by_target
+      resolver_specs_by_target
     rescue Molinillo::ResolverError => e
       handle_resolver_error(e)
     end
 
-    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
+    # @return [Hash{Podfile::TargetDefinition => Array<ResolverSpecification>}]
     #         returns the resolved specifications grouped by target.
     #
     # @note   The returned specifications can be subspecs.
     #
-    def specs_by_target
-      @specs_by_target ||= {}.tap do |specs_by_target|
+    def resolver_specs_by_target
+      @resolver_specs_by_target ||= {}.tap do |resolver_specs_by_target|
         podfile.target_definition_list.each do |target|
           dependencies = {}
           specs = target.dependencies.map(&:name).flat_map do |name|
             node = @activated.vertex_named(name)
-            valid_dependencies_for_target_from_node(target, dependencies, node) << node
+            (valid_dependencies_for_target_from_node(target, dependencies, node) << node).map { |s| [s, node.payload.test_specification?] }
           end
 
-          specs_by_target[target] = specs.
-            map(&:payload).
-            uniq.
+          resolver_specs_by_target[target] = specs.
+            group_by(&:first).
+            map { |vertex, spec_test_only_tuples| ResolverSpecification.new(vertex.payload, spec_test_only_tuples.map { |tuple| tuple[1] }.all?) }.
             sort_by(&:name)
         end
       end
@@ -179,21 +212,33 @@ module Pod
     # @param  [Specification] spec the specification in question.
     #
     def requirement_satisfied_by?(requirement, activated, spec)
-      existing_vertices = activated.vertices.values.select do |v|
-        Specification.root_name(v.name) == requirement.root_name
-      end
-      existing = existing_vertices.map(&:payload).compact.first
-      requirement_satisfied =
-        if existing
-          existing.version == spec.version && requirement.requirement.satisfied_by?(spec.version)
+      version = spec.version
+      return false unless requirement.requirement.satisfied_by?(version)
+      shared_possibility_versions, prerelease_requirement = possibility_versions_for_root_name(requirement, activated)
+      return false if !shared_possibility_versions.empty? && !shared_possibility_versions.include?(version)
+      return false if version.prerelease? && !prerelease_requirement
+      return false unless spec_is_platform_compatible?(activated, requirement, spec)
+      true
+    end
+
+    def possibility_versions_for_root_name(requirement, activated)
+      prerelease_requirement = requirement.prerelease? || requirement.external_source
+      existing = activated.vertices.values.flat_map do |vertex|
+        next unless vertex.payload
+        next unless Specification.root_name(vertex.name) == requirement.root_name
+
+        prerelease_requirement ||= vertex.requirements.any? { |r| r.prerelease? || r.external_source }
+
+        if vertex.payload.respond_to?(:possibilities)
+          vertex.payload.possibilities.map(&:version)
         else
-          requirement.requirement.satisfied_by? spec.version
+          vertex.payload.version
         end
-      requirement_satisfied && !(
-        spec.version.prerelease? &&
-        existing_vertices.flat_map(&:requirements).none? { |r| r.prerelease? || r.external_source }
-      ) && spec_is_platform_compatible?(activated, requirement, spec)
+      end.compact
+
+      [existing, prerelease_requirement]
     end
+    private :possibility_versions_for_root_name
 
     # Sort dependencies so that the ones that are easiest to resolve are first.
     # Easiest to resolve is (usually) defined by:
@@ -399,64 +444,69 @@ module Pod
     # @param  [Molinillo::ResolverError] error
     #
     def handle_resolver_error(error)
-      message = error.message.dup
+      message = error.message
       type = Informative
       case error
       when Molinillo::VersionConflict
-        error.conflicts.each do |name, conflict|
-          local_pod_parent = conflict.requirement_trees.flatten.reverse.find(&:local?)
-          lockfile_reqs = conflict.requirements[name_for_locking_dependency_source]
-          if lockfile_reqs && lockfile_reqs.last && lockfile_reqs.last.prerelease? && !conflict.existing
-            message = 'Due to the previous naïve CocoaPods resolver, ' \
-              "you were using a pre-release version of `#{name}`, " \
-              'without explicitly asking for a pre-release version, which now leads to a conflict. ' \
-              'Please decide to either use that pre-release version by adding the ' \
-              'version requirement to your Podfile ' \
-              "(e.g. `pod '#{name}', '#{lockfile_reqs.map(&:requirement).join("', '")}'`) " \
-              "or revert to a stable version by running `pod update #{name}`."
-          elsif local_pod_parent && !specifications_for_dependency(conflict.requirement).empty? && !conflict.possibility
-            # Conflict was caused by a requirement from a local dependency.
-            # Tell user to use `pod update`.
-            message << "\n\nIt seems like you've changed the constraints of dependency `#{name}` " \
-            "inside your development pod `#{local_pod_parent.name}`.\nYou should run `pod update #{name}` to apply " \
-            "changes you've made."
-          elsif (conflict.possibility && conflict.possibility.version.prerelease?) &&
-              (conflict.requirement && !(
-              conflict.requirement.prerelease? ||
-              conflict.requirement.external_source)
-              )
-            # Conflict was caused by not specifying an explicit version for the requirement #[name],
-            # and there is no available stable version satisfying constraints for the requirement.
-            message = "There are only pre-release versions available satisfying the following requirements:\n"
-            conflict.requirements.values.flatten.each do |r|
-              unless search_for(r).empty?
-                message << "\n\t'#{name}', '#{r.requirement}'\n"
+        message = error.message_with_trees(
+          :solver_name => 'CocoaPods',
+          :possibility_type => 'pod',
+          :version_for_spec => lambda(&:version),
+          :additional_message_for_conflict => lambda do |o, name, conflict|
+            local_pod_parent = conflict.requirement_trees.flatten.reverse.find(&:local?)
+            lockfile_reqs = conflict.requirements[name_for_locking_dependency_source]
+            if lockfile_reqs && lockfile_reqs.last && lockfile_reqs.last.prerelease? && !conflict.existing
+              o << "\nDue to the previous naïve CocoaPods resolver, " \
+                "you were using a pre-release version of `#{name}`, " \
+                'without explicitly asking for a pre-release version, which now leads to a conflict. ' \
+                'Please decide to either use that pre-release version by adding the ' \
+                'version requirement to your Podfile ' \
+                "(e.g. `pod '#{name}', '#{lockfile_reqs.map(&:requirement).join("', '")}'`) " \
+                "or revert to a stable version by running `pod update #{name}`."
+            elsif local_pod_parent && !specifications_for_dependency(conflict.requirement).empty? && !conflict.possibility && conflict.locked_requirement
+              # Conflict was caused by a requirement from a local dependency.
+              # Tell user to use `pod update`.
+              o << "\nIt seems like you've changed the constraints of dependency `#{name}` " \
+              "inside your development pod `#{local_pod_parent.name}`.\nYou should run `pod update #{name}` to apply " \
+              "changes you've made."
+            elsif (conflict.possibility && conflict.possibility.version.prerelease?) &&
+                (conflict.requirement && !(
+                conflict.requirement.prerelease? ||
+                conflict.requirement.external_source)
+                )
+              # Conflict was caused by not specifying an explicit version for the requirement #[name],
+              # and there is no available stable version satisfying constraints for the requirement.
+              o << "\nThere are only pre-release versions available satisfying the following requirements:\n"
+              conflict.requirements.values.flatten.each do |r|
+                unless search_for(r).empty?
+                  o << "\n\t'#{name}', '#{r.requirement}'\n"
+                end
               end
-            end
-            message << "\nYou should explicitly specify the version in order to install a pre-release version"
-          elsif !conflict.existing
-            conflicts = conflict.requirements.values.flatten.uniq
-            found_conflicted_specs = conflicts.reject { |c| search_for(c).empty? }
-            if found_conflicted_specs.empty?
-              # There are no existing specification inside any of the spec repos with given requirements.
-              type = NoSpecFoundError
-              dependencies = conflicts.count == 1 ? 'dependency' : 'dependencies'
-              message << "\n\nNone of your spec sources contain a spec satisfying "\
-                "the #{dependencies}: `#{conflicts.join(', ')}`." \
-                "\n\nYou have either:"
-              unless specs_updated?
-                message << "\n * out-of-date source repos which you can update with `pod repo update` or with `pod install --repo-update`."
+              o << "\nYou should explicitly specify the version in order to install a pre-release version"
+            elsif !conflict.existing
+              conflicts = conflict.requirements.values.flatten.uniq
+              found_conflicted_specs = conflicts.reject { |c| search_for(c).empty? }
+              if found_conflicted_specs.empty?
+                # There are no existing specification inside any of the spec repos with given requirements.
+                type = NoSpecFoundError
+                dependencies = conflicts.count == 1 ? 'dependency' : 'dependencies'
+                o << "\nNone of your spec sources contain a spec satisfying "\
+                  "the #{dependencies}: `#{conflicts.join(', ')}`." \
+                  "\n\nYou have either:"
+                unless specs_updated?
+                  o << "\n * out-of-date source repos which you can update with `pod repo update` or with `pod install --repo-update`."
+                end
+                o << "\n * mistyped the name or version." \
+                  "\n * not added the source repo that hosts the Podspec to your Podfile." \
+                  "\n\nNote: as of CocoaPods 1.0, `pod repo update` does not happen on `pod install` by default."
+
+              else
+                o << "\nSpecs satisfying the `#{conflicts.join(', ')}` dependency were found, " \
+                  'but they required a higher minimum deployment target.'
               end
-              message << "\n * mistyped the name or version." \
-                "\n * not added the source repo that hosts the Podspec to your Podfile." \
-                "\n\nNote: as of CocoaPods 1.0, `pod repo update` does not happen on `pod install` by default."
-
-            else
-              message << "\n\nSpecs satisfying the `#{conflicts.join(', ')}` dependency were found, " \
-                'but they required a higher minimum deployment target.'
             end
-          end
-        end
+          end,
+        )
       end
       raise type, message
     end
@@ -500,7 +550,6 @@ module Pod
 
         dependency_nodes + dependency_nodes.flat_map do |item|
           node_result = valid_dependencies_for_target_from_node(target, dependencies, item)
-
           node_result
         end
       end