cocoapods 0.37.2 → 0.38.0.beta.1

data/lib/cocoapods/generator/xcconfig/private_pod_xcconfig.rb

@@ -60,13 +60,13 @@ module Pod
             # 'USE_HEADERMAP' => 'NO'
           }
 
-          if target.requires_frameworks?
+          if target.requires_frameworks? && target.scoped?
             # Only quote the FRAMEWORK_SEARCH_PATHS entry, because it’s a setting that takes multiple values.
             # In addition, quoting CONFIGURATION_BUILD_DIR would make it be interpreted as a relative path.
             build_settings = {
               'PODS_FRAMEWORK_BUILD_PATH' => target.configuration_build_dir,
-              'CONFIGURATION_BUILD_DIR' => '$PODS_FRAMEWORK_BUILD_PATH',
               'FRAMEWORK_SEARCH_PATHS' => '"$PODS_FRAMEWORK_BUILD_PATH"',
+              'CONFIGURATION_BUILD_DIR' => '$PODS_FRAMEWORK_BUILD_PATH',
             }
             config.merge!(build_settings)
           end

data/lib/cocoapods/generator/xcconfig/xcconfig_helper.rb

@@ -33,7 +33,7 @@ module Pod
         #
         def self.default_ld_flags(target)
           ld_flags = '-ObjC'
-          if target.target_definition.podfile.set_arc_compatibility_flag? &&
+          if target.podfile.set_arc_compatibility_flag? &&
               target.spec_consumers.any?(&:requires_arc?)
             ld_flags << ' -fobjc-arc'
           end
@@ -70,7 +70,7 @@ module Pod
         #         The xcconfig to edit.
         #
         def self.add_spec_build_settings_to_xcconfig(consumer, xcconfig)
-          xcconfig.merge!(consumer.xcconfig)
+          xcconfig.merge!(consumer.pod_target_xcconfig)
           xcconfig.libraries.merge(consumer.libraries)
           xcconfig.frameworks.merge(consumer.frameworks)
           xcconfig.weak_frameworks.merge(consumer.weak_frameworks)
@@ -189,7 +189,7 @@ module Pod
             search_paths = xcconfig.attributes['FRAMEWORK_SEARCH_PATHS'] ||= ''
             search_paths_to_add = []
             search_paths_to_add << '$(inherited)'
-            if platform == :ios
+            if platform == :ios || platform == :watchos
               search_paths_to_add << '"$(SDKROOT)/Developer/Library/Frameworks"'
             else
               search_paths_to_add << '"$(DEVELOPER_LIBRARY_DIR)/Frameworks"'

data/lib/cocoapods/installer.rb

@@ -31,8 +31,10 @@ module Pod
     autoload :AggregateTargetInstaller, 'cocoapods/installer/target_installer/aggregate_target_installer'
     autoload :Analyzer,                 'cocoapods/installer/analyzer'
     autoload :FileReferencesInstaller,  'cocoapods/installer/file_references_installer'
-    autoload :HooksContext,             'cocoapods/installer/hooks_context'
+    autoload :PostInstallHooksContext,  'cocoapods/installer/post_install_hooks_context'
+    autoload :PreInstallHooksContext,   'cocoapods/installer/pre_install_hooks_context'
     autoload :Migrator,                 'cocoapods/installer/migrator'
+    autoload :PodfileValidator,         'cocoapods/installer/podfile_validator'
     autoload :PodSourceInstaller,       'cocoapods/installer/pod_source_installer'
     autoload :PodSourcePreparer,        'cocoapods/installer/pod_source_preparer'
     autoload :PodTargetInstaller,       'cocoapods/installer/target_installer/pod_target_installer'
@@ -106,12 +108,19 @@ module Pod
         sandbox.prepare
         ensure_plugins_are_installed!
         Migrator.migrate(sandbox)
+        run_plugins_pre_install_hooks
       end
     end
 
     def resolve_dependencies
+      analyzer = create_analyzer
+
+      UI.section 'Updating local specs repositories' do
+        analyzer.update_repositories
+      end unless config.skip_repo_update?
+
       UI.section 'Analyzing dependencies' do
-        analyze
+        analyze(analyzer)
         validate_build_configurations
         prepare_for_legacy_compatibility
         clean_sandbox
@@ -122,7 +131,7 @@ module Pod
       UI.section 'Downloading dependencies' do
         create_file_accessors
         install_pod_sources
-        run_pre_install_hooks
+        run_podfile_pre_install_hooks
         clean_pod_sources
         lock_pod_sources
       end
@@ -160,11 +169,19 @@ module Pod
     #
     attr_reader :names_of_pods_to_install
 
-    # @return [Array<AggregateTarget>] The Podfile targets containing library
-    #         dependencies.
+    # @return [Array<AggregateTarget>] The model representations of an
+    #         aggregation of pod targets generated for a target definition
+    #         in the Podfile as result of the analyzer.
     #
     attr_reader :aggregate_targets
 
+    # @return [Array<PodTarget>] The model representations of pod targets
+    #         generated as result of the analyzer.
+    #
+    def pod_targets
+      aggregate_targets.map(&:pod_targets).flatten.uniq
+    end
+
     # @return [Array<Specification>] The specifications that where installed.
     #
     attr_accessor :installed_specs
@@ -179,33 +196,27 @@ module Pod
     #
     # @return [void]
     #
-    # @note   The warning about the version of the Lockfile doesn't use the
-    #         `UI.warn` method because it prints the output only at the end
-    #         of the installation. At that time CocoaPods could have crashed.
-    #
-    def analyze
-      if lockfile && lockfile.cocoapods_version > Version.new(VERSION)
-        STDERR.puts '[!] The version of CocoaPods used to generate ' \
-          "the lockfile (#{lockfile.cocoapods_version}) is "\
-          "higher than the version of the current executable (#{VERSION}). " \
-          'Incompatibility issues may arise.'.yellow
-      end
-
-      analyzer = Analyzer.new(sandbox, podfile, lockfile)
+    def analyze(analyzer = create_analyzer)
       analyzer.update = update
       @analysis_result = analyzer.analyze
       @aggregate_targets = analyzer.result.targets
     end
 
+    def create_analyzer
+      Analyzer.new(sandbox, podfile, lockfile)
+    end
+
     # Ensures that the white-listed build configurations are known to prevent
     # silent typos.
     #
     # @raise  If an unknown user configuration is found.
     #
     def validate_build_configurations
-      whitelisted_configs = pod_targets.map do |target|
-        target.target_definition.all_whitelisted_configurations.map(&:downcase)
-      end.flatten.uniq
+      whitelisted_configs = pod_targets.
+        flat_map(&:target_definitions).
+        flat_map(&:all_whitelisted_configurations).
+        map(&:downcase).
+        uniq
       all_user_configurations = analysis_result.all_user_build_configurations.keys.map(&:downcase)
 
       remainder = whitelisted_configs - all_user_configurations
@@ -251,16 +262,14 @@ module Pod
     #       created by the Pod source installer as well.
     #
     def create_file_accessors
-      aggregate_targets.each do |target|
-        target.pod_targets.each do |pod_target|
-          pod_root = sandbox.pod_dir(pod_target.root_spec.name)
-          path_list = Sandbox::PathList.new(pod_root)
-          file_accessors = pod_target.specs.map do |spec|
-            Sandbox::FileAccessor.new(path_list, spec.consumer(pod_target.platform))
-          end
-          pod_target.file_accessors ||= []
-          pod_target.file_accessors.concat(file_accessors)
+      pod_targets.each do |pod_target|
+        pod_root = sandbox.pod_dir(pod_target.root_spec.name)
+        path_list = Sandbox::PathList.new(pod_root)
+        file_accessors = pod_target.specs.map do |spec|
+          Sandbox::FileAccessor.new(path_list, spec.consumer(pod_target.platform))
         end
+        pod_target.file_accessors ||= []
+        pod_target.file_accessors.concat(file_accessors)
       end
     end
 
@@ -342,7 +351,7 @@ module Pod
     def determine_dependency_product_types
       aggregate_targets.each do |aggregate_target|
         aggregate_target.pod_targets.each do |pod_target|
-          pod_target.host_requires_frameworks = aggregate_target.requires_frameworks?
+          pod_target.host_requires_frameworks ||= aggregate_target.requires_frameworks?
         end
       end
     end
@@ -371,7 +380,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.flat_map(&:dependencies)
+          dependencies = pod_targets.select(&:should_build?).flat_map(&:dependencies)
           dependended_upon_targets = pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
 
           static_libs = dependended_upon_targets.flat_map(&:file_accessors).flat_map do |fa|
@@ -403,6 +412,15 @@ module Pod
       end
     end
 
+    # Runs the registered callbacks for the plugins pre install hooks.
+    #
+    # @return [void]
+    #
+    def run_plugins_pre_install_hooks
+      context = PreInstallHooksContext.generate(sandbox, podfile, lockfile)
+      HooksManager.run(:pre_install, context, podfile.plugins)
+    end
+
     # Performs any post-installation actions
     #
     # @return [void]
@@ -415,7 +433,7 @@ module Pod
     # Runs the registered callbacks for the plugins post install hooks.
     #
     def run_plugins_post_install_hooks
-      context = HooksContext.generate(sandbox, aggregate_targets)
+      context = PostInstallHooksContext.generate(sandbox, aggregate_targets)
       HooksManager.run(:post_install, context, podfile.plugins)
     end
 
@@ -491,9 +509,11 @@ module Pod
         platforms = aggregate_targets.map(&:platform)
         osx_deployment_target = platforms.select { |p| p.name == :osx }.map(&:deployment_target).min
         ios_deployment_target = platforms.select { |p| p.name == :ios }.map(&:deployment_target).min
+        watchos_deployment_target = platforms.select { |p| p.name == :watchos }.map(&:deployment_target).min
         @pods_project.build_configurations.each do |build_configuration|
           build_configuration.build_settings['MACOSX_DEPLOYMENT_TARGET'] = osx_deployment_target.to_s if osx_deployment_target
           build_configuration.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = ios_deployment_target.to_s if ios_deployment_target
+          build_configuration.build_settings['WATCHOS_DEPLOYMENT_TARGET'] = watchos_deployment_target.to_s if watchos_deployment_target
           build_configuration.build_settings['STRIP_INSTALLED_PRODUCT'] = 'NO'
           build_configuration.build_settings['CLANG_ENABLE_OBJC_ARC'] = 'YES'
         end
@@ -519,7 +539,7 @@ module Pod
     def install_libraries
       UI.message '- Installing targets' do
         pod_targets.sort_by(&:name).each do |pod_target|
-          next if pod_target.target_definition.dependencies.empty?
+          next if pod_target.target_definitions.flat_map(&:dependencies).empty?
           target_installer = PodTargetInstaller.new(sandbox, pod_target)
           target_installer.install!
         end
@@ -610,12 +630,8 @@ module Pod
     # @return [void]
     #
     def share_development_pod_schemes
-      development_pod_targets = sandbox.development_pods.keys.map do |pod|
-        pods_project.targets.select { |target| target.name =~ /^Pods-.*-#{pod}$/ }
-      end.flatten
-
-      development_pod_targets.each do |pod_target|
-        Xcodeproj::XCScheme.share_scheme(pods_project.path, pod_target.name)
+      development_pod_targets.select(&:should_build?).each do |pod_target|
+        Xcodeproj::XCScheme.share_scheme(pods_project.path, pod_target.label)
       end
     end
 
@@ -671,7 +687,7 @@ module Pod
     #
     # @return [void]
     #
-    def run_pre_install_hooks
+    def run_podfile_pre_install_hooks
       UI.message '- Running pre install hooks' do
         executed = run_podfile_pre_install_hook
         UI.message '- Podfile' if executed
@@ -685,7 +701,7 @@ module Pod
     # @return [Bool] Whether the hook was run.
     #
     def run_podfile_pre_install_hook
-      podfile.pre_install!(installer_rep)
+      podfile.pre_install!(self)
     rescue => e
       raise Informative, 'An error occurred while processing the pre-install ' \
         'hook of the Podfile.' \
@@ -713,7 +729,7 @@ module Pod
     # @return [Bool] Whether the hook was run.
     #
     def run_podfile_post_install_hook
-      podfile.post_install!(installer_rep)
+      podfile.post_install!(self)
     rescue => e
       raise Informative, 'An error occurred while processing the post-install ' \
         'hook of the Podfile.' \
@@ -724,76 +740,15 @@ module Pod
 
     public
 
-    # @!group Hooks Data
-
-    # Creates a hook representation for this installer.
-    #
-    # @return [InstallerRepresentation]
-    #
-    def installer_rep
-      Hooks::InstallerRepresentation.new(self)
-    end
-
-    # Creates a hook representation for a Pod.
+    # @return [Array<Library>] The targets of the development pods generated by
+    #         the installation process.
     #
-    # @param  [String] pod
-    #         The name of the pod.
-    #
-    # @return [PodRepresentation]
-    #
-    def pod_rep(pod)
-      all_file_accessors = pod_targets.map(&:file_accessors).flatten.compact
-      file_accessors = all_file_accessors.select { |fa| fa.spec.root.name == pod }
-      Hooks::PodRepresentation.new(pod, file_accessors)
-    end
-
-    # Creates a hook representation for a given aggregate target.
-    #
-    # @param  [AggregateTarget] aggregate_target
-    #         the aggregate target
-    #
-    # @return [LibraryRepresentation]
-    #
-    def library_rep(aggregate_target)
-      Hooks::LibraryRepresentation.new(sandbox, aggregate_target)
-    end
-
-    # Creates hook representations for all aggregate targets.
-    #
-    # @return [Array<LibraryRepresentation>]
-    #
-    def library_reps
-      @library_reps ||= aggregate_targets.map { |lib| library_rep(lib) }
-    end
-
-    # Creates hook representations for all #root_specs.
-    #
-    # @return [Array<PodRepresentation>]
-    #
-    def pod_reps
-      root_specs.sort_by(&:name).map { |spec| pod_rep(spec.name) }
-    end
-
-    # Returns the libraries which use the given specification.
-    #
-    # @param  [Specification] spec
-    #         The specification for which the client libraries are needed.
-    #
-    # @return [Array<Library>] The library.
-    #
-    def libraries_using_spec(spec)
-      aggregate_targets.select do |aggregate_target|
-        aggregate_target.pod_targets.any? { |pod_target| pod_target.specs.include?(spec) }
+    def development_pod_targets
+      pod_targets.select do |pod_target|
+        sandbox.development_pods.keys.include?(pod_target.pod_name)
       end
     end
 
-    # @return [Array<Library>] The libraries generated by the installation
-    #         process.
-    #
-    def pod_targets
-      aggregate_targets.map(&:pod_targets).flatten
-    end
-
     #-------------------------------------------------------------------------#
 
     private

data/lib/cocoapods/installer/analyzer.rb

@@ -6,9 +6,12 @@ module Pod
     class Analyzer
       include Config::Mixin
 
-      autoload :SandboxAnalyzer, 'cocoapods/installer/analyzer/sandbox_analyzer'
-
+      autoload :AnalysisResult,            'cocoapods/installer/analyzer/analysis_result'
+      autoload :SandboxAnalyzer,           'cocoapods/installer/analyzer/sandbox_analyzer'
+      autoload :SpecsState,                'cocoapods/installer/analyzer/specs_state'
       autoload :LockingDependencyAnalyzer, 'cocoapods/installer/analyzer/locking_dependency_analyzer'
+      autoload :TargetInspectionResult,    'cocoapods/installer/analyzer/target_inspection_result'
+      autoload :TargetInspector,           'cocoapods/installer/analyzer/target_inspector'
 
       # @return [Sandbox] The sandbox where the Pods should be installed.
       #
@@ -37,7 +40,6 @@ module Pod
 
         @update = false
         @allow_pre_downloads = true
-        @archs_by_target_def = {}
       end
 
       # Performs the analysis.
@@ -52,9 +54,14 @@ module Pod
       # @return [AnalysisResult]
       #
       def analyze(allow_fetches = true)
-        update_repositories_if_needed if allow_fetches
+        validate_podfile!
+        validate_lockfile_version!
         @result = AnalysisResult.new
-        compute_target_platforms
+        if config.integrate_targets?
+          @result.target_inspections = inspect_targets_to_integrate
+        else
+          verify_platforms_specified!
+        end
         @result.podfile_state = generate_podfile_state
         @locked_dependencies  = generate_version_locking_dependencies
 
@@ -143,8 +150,30 @@ module Pod
 
       private
 
+      def validate_podfile!
+        validator = Installer::PodfileValidator.new(podfile)
+        validator.validate
+
+        unless validator.valid?
+          raise Informative, validator.message
+        end
+      end
+
       # @!group Analysis steps
 
+      # @note   The warning about the version of the Lockfile doesn't use the
+      #         `UI.warn` method because it prints the output only at the end
+      #         of the installation. At that time CocoaPods could have crashed.
+      #
+      def validate_lockfile_version!
+        if lockfile && lockfile.cocoapods_version > Version.new(VERSION)
+          STDERR.puts '[!] The version of CocoaPods used to generate ' \
+            "the lockfile (#{lockfile.cocoapods_version}) is "\
+            "higher than the version of the current executable (#{VERSION}). " \
+            'Incompatibility issues may arise.'.yellow
+        end
+      end
+
       # Compares the {Podfile} with the {Lockfile} in order to detect which
       # dependencies should be locked.
       #
@@ -174,32 +203,31 @@ module Pod
         end
       end
 
+      public
+
       # Updates the git source repositories unless the config indicates to skip it.
       #
-      def update_repositories_if_needed
-        unless config.skip_repo_update?
-          UI.section 'Updating spec repositories' do
-            sources.each do |source|
-              if SourcesManager.git_repo?(source.repo)
-                SourcesManager.update(source.name)
-              else
-                UI.message "Skipping `#{source.name}` update because the repository is not a git source repository."
-              end
-            end
+      def update_repositories
+        sources.each do |source|
+          if SourcesManager.git_repo?(source.repo)
+            SourcesManager.update(source.name)
+          else
+            UI.message "Skipping `#{source.name}` update because the repository is not a git source repository."
           end
         end
       end
 
-      # Creates the models that represent the libraries generated by CocoaPods.
+      private
+
+      # Creates the models that represent the targets generated by CocoaPods.
       #
-      # @return [Array<Target>] the generated libraries.
+      # @return [Array<AggregateTarget>]
       #
       def generate_targets
-        targets = []
-        result.specs_by_target.each do |target_definition, specs|
-          targets << generate_target(target_definition, specs)
+        pod_targets = generate_pod_targets(result.specs_by_target)
+        result.specs_by_target.map do |target_definition, _|
+          generate_target(target_definition, pod_targets)
         end
-        targets
       end
 
       # Setup the aggregate target for a single user target
@@ -207,26 +235,22 @@ module Pod
       # @param  [TargetDefinition] target_definition
       #         the target definition for the user target.
       #
-      # @param  [Array<Specification>] specs
-      #         the specifications that need to be installed grouped by the
-      #         given target definition.
+      # @param  [Array<PodTarget>] pod_targets
+      #         the pod targets, which were generated.
       #
       # @return [AggregateTarget]
       #
-      def generate_target(target_definition, specs)
+      def generate_target(target_definition, pod_targets)
         target = AggregateTarget.new(target_definition, sandbox)
         target.host_requires_frameworks |= target_definition.uses_frameworks?
 
         if config.integrate_targets?
-          project_path = compute_user_project_path(target_definition)
-          user_project = Xcodeproj::Project.open(project_path)
-          native_targets = compute_user_project_targets(target_definition, user_project)
-
-          target.user_project_path = project_path
-          target.client_root = project_path.dirname
-          target.user_target_uuids = native_targets.map(&:uuid)
-          target.user_build_configurations = compute_user_build_configurations(target_definition, native_targets)
-          target.archs = @archs_by_target_def[target_definition]
+          target_inspection = result.target_inspections[target_definition]
+          target.user_project_path = target_inspection.project_path
+          target.client_root = target.user_project_path.dirname
+          target.user_target_uuids = target_inspection.project_target_uuids
+          target.user_build_configurations = target_inspection.build_configurations
+          target.archs = target_inspection.archs
         else
           target.client_root = config.installation_root
           target.user_target_uuids = []
@@ -236,48 +260,119 @@ module Pod
           end
         end
 
-        target.pod_targets = generate_pod_targets(target, specs)
-
+        target.pod_targets = pod_targets.select do |pod_target|
+          pod_target.target_definitions.include?(target_definition)
+        end
         target
       end
 
-      # Setup the pod targets for an aggregate target. Group specs and subspecs
-      # by their root to create a {PodTarget} for each spec.
+      # Setup the pod targets for an aggregate target. Deduplicates resulting
+      # targets by grouping by grouping by platform and subspec by their root
+      # to create a {PodTarget} for each spec.
       #
-      # @param  [AggregateTarget] target
-      #         the aggregate target
+      # @param  [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target
+      #         the resolved specifications grouped by target.
       #
-      # @param  [Array<Specification>] specs
-      #         the specifications that need to be installed.
+      # @return [Array<PodTarget>]
+      #
+      def generate_pod_targets(specs_by_target)
+        if config.deduplicate_targets?
+          all_specs = specs_by_target.flat_map do |target_definition, dependent_specs|
+            dependent_specs.group_by(&:root).map do |root_spec, specs|
+              [root_spec, specs, target_definition]
+            end
+          end
+
+          distinct_targets = all_specs.each_with_object({}) do |dependency, hash|
+            root_spec, specs, target_definition = *dependency
+            hash[root_spec] ||= {}
+            (hash[root_spec][[specs, target_definition.platform]] ||= []) << target_definition
+          end
+
+          pod_targets = distinct_targets.flat_map do |_, targets_by_distinctors|
+            if targets_by_distinctors.count > 1
+              # There are different sets of subspecs or the spec is used across different platforms
+              targets_by_distinctors.map do |distinctor, target_definitions|
+                specs, _ = *distinctor
+                generate_pod_target(target_definitions, specs, :scoped => true)
+              end
+            else
+              (specs, _), target_definitions = targets_by_distinctors.first
+              generate_pod_target(target_definitions, specs)
+            end
+          end
+
+          # A `PodTarget` can't be deduplicated if any of its
+          # transitive dependencies can't be deduplicated.
+          pod_targets.flat_map do |target|
+            dependent_targets = transitive_dependencies_for_pod_target(target, pod_targets)
+            if dependent_targets.any?(&:scoped?)
+              target.scoped
+            else
+              target
+            end
+          end
+        else
+          specs_by_target.flat_map do |target_definition, specs|
+            grouped_specs = specs.group_by.group_by(&:root).values.uniq
+            grouped_specs.flat_map do |pod_specs|
+              generate_pod_target([target_definition], pod_specs, :scoped => true)
+            end
+          end
+        end
+      end
+
+      # Finds the names of the Pods upon which the given target _transitively_
+      # depends.
+      #
+      # @note: This is implemented in the analyzer, because we don't have to
+      #        care about the requirements after dependency resolution.
+      #
+      # @param  [PodTarget] pod_target
+      #         The pod target, whose dependencies should be returned.
+      #
+      # @param  [Array<PodTarget>] targets
+      #         All pod targets, which are integrated alongside.
       #
       # @return [Array<PodTarget>]
       #
-      def generate_pod_targets(target, specs)
-        grouped_specs = specs.group_by(&:root).values.uniq
-        grouped_specs.map do |pod_specs|
-          generate_pod_target(target, pod_specs)
+      def transitive_dependencies_for_pod_target(pod_target, targets)
+        if targets.any?
+          dependent_targets = pod_target.dependencies.flat_map do |dep|
+            targets.select { |t| t.pod_name == dep }
+          end
+          remaining_targets = targets - dependent_targets
+          dependent_targets + dependent_targets.flat_map do |target|
+            transitive_dependencies_for_pod_target(target, remaining_targets)
+          end
+        else
+          []
         end
       end
 
-      # Create a target for each spec group and add it to the aggregate target
+      # Create a target for each spec group
       #
-      # @param  [AggregateTarget] target
+      # @param  [TargetDefinitions] target_definitions
       #         the aggregate target
       #
       # @param  [Array<Specification>] specs
       #         the specifications of an equal root.
       #
+      # @param  [Bool] scoped
+      #         whether the pod target should be scoped
+      #
       # @return [PodTarget]
       #
-      def generate_pod_target(target, pod_specs)
-        pod_target = PodTarget.new(pod_specs, target.target_definition, sandbox)
+      def generate_pod_target(target_definitions, pod_specs, scoped: false)
+        pod_target = PodTarget.new(pod_specs, target_definitions, sandbox, scoped)
 
         if config.integrate_targets?
-          pod_target.user_build_configurations = target.user_build_configurations
-          pod_target.archs = @archs_by_target_def[target.target_definition]
+          target_inspections = result.target_inspections.select { |t, _| target_definitions.include?(t) }.values
+          pod_target.user_build_configurations = target_inspections.map(&:build_configurations).reduce({}, &:merge)
+          pod_target.archs = target_inspections.flat_map(&:archs).compact.uniq.sort
         else
           pod_target.user_build_configurations = {}
-          if target.platform.name == :osx
+          if target_definitions.first.platform.name == :osx
             pod_target.archs = '$(ARCHS_STANDARD_64_BIT)'
           end
         end
@@ -438,6 +533,7 @@ module Pod
         UI.section "Resolving dependencies of #{UI.path podfile.defined_in_file}" do
           resolver = Resolver.new(sandbox, podfile, locked_dependencies, sources)
           specs_by_target = resolver.resolve
+          specs_by_target.values.flatten(1).each(&:validate_cocoapods_version)
         end
         specs_by_target
       end
@@ -529,305 +625,40 @@ module Pod
 
       # @!group Analysis sub-steps
 
-      # Returns the path of the user project that the {TargetDefinition}
-      # should integrate.
-      #
-      # @raise  If the project is implicit and there are multiple projects.
-      #
-      # @raise  If the path doesn't exits.
-      #
-      # @return [Pathname] the path of the user project.
-      #
-      def compute_user_project_path(target_definition)
-        if target_definition.user_project_path
-          path = config.installation_root + target_definition.user_project_path
-          path = "#{path}.xcodeproj" unless File.extname(path) == '.xcodeproj'
-          path = Pathname.new(path)
-          unless path.exist?
-            raise Informative, 'Unable to find the Xcode project ' \
-              "`#{path}` for the target `#{target_definition.label}`."
-          end
-        else
-          xcodeprojs = config.installation_root.children.select { |e| e.fnmatch('*.xcodeproj') }
-          if xcodeprojs.size == 1
-            path = xcodeprojs.first
-          else
-            raise Informative, 'Could not automatically select an Xcode project. ' \
-              "Specify one in your Podfile like so:\n\n" \
-              "    xcodeproj 'path/to/Project.xcodeproj'\n"
-          end
-        end
-        path
-      end
-
-      # Returns a list of the targets from the project of {TargetDefinition}
-      # that needs to be integrated.
+      # Checks whether the platform is specified if not integrating
       #
-      # @note   The method first looks if there is a target specified with
-      #         the `link_with` option of the {TargetDefinition}. Otherwise
-      #         it looks for the target that has the same name of the target
-      #         definition.  Finally if no target was found the first
-      #         encountered target is returned (it is assumed to be the one
-      #         to integrate in simple projects).
-      #
-      # @note   This will only return targets that do **not** already have
-      #         the Pods library in their frameworks build phase.
-      #
-      #
-      def compute_user_project_targets(target_definition, user_project)
-        if link_with = target_definition.link_with
-          targets = native_targets(user_project).select { |t| link_with.include?(t.name) }
-          raise Informative, "Unable to find the targets named `#{link_with.to_sentence}` to link with target definition `#{target_definition.name}`" if targets.empty?
-        elsif target_definition.link_with_first_target?
-          targets = [native_targets(user_project).first].compact
-          raise Informative, 'Unable to find a target' if targets.empty?
-        else
-          target = native_targets(user_project).find { |t| t.name == target_definition.name.to_s }
-          targets = [target].compact
-          raise Informative, "Unable to find a target named `#{target_definition.name}`" if targets.empty?
-        end
-        targets
-      end
-
-      # @return [Array<PBXNativeTarget>] Returns the user’s targets, excluding
-      #         aggregate targets.
-      #
-      def native_targets(user_project)
-        user_project.targets.reject do |target|
-          target.is_a? Xcodeproj::Project::Object::PBXAggregateTarget
-        end
-      end
-
-      # Checks if any of the targets for the {TargetDefinition} computed before
-      # by #compute_user_project_targets require to be build as a framework due
-      # the presence of Swift source code in any of the source build phases.
-      #
-      # @param  [TargetDefinition] target_definition
-      #         the target definition
-      #
-      # @param  [Array<PBXNativeTarget>] native_targets
-      #         the targets which are checked for presence of Swift source code
-      #
-      # @return [Boolean] Whether the user project targets to integrate into
-      #         uses Swift
-      #
-      def compute_user_project_targets_require_framework(target_definition, native_targets)
-        file_predicate = nil
-        file_predicate = proc do |file_ref|
-          if file_ref.respond_to?(:last_known_file_type)
-            file_ref.last_known_file_type == 'sourcecode.swift'
-          elsif file_ref.respond_to?(:files)
-            file_ref.files.any?(&file_predicate)
-          else
-            false
-          end
-        end
-        target_definition.platform.supports_dynamic_frameworks? || native_targets.any? do |target|
-          target.source_build_phase.files.any? do |build_file|
-            file_predicate.call(build_file.file_ref)
-          end
-        end
-      end
-
-      # @return [Hash{String=>Symbol}] A hash representing the user build
-      #         configurations where each key corresponds to the name of a
-      #         configuration and its value to its type (`:debug` or `:release`).
-      #
-      def compute_user_build_configurations(target_definition, user_targets)
-        if user_targets
-          user_targets.map { |t| t.build_configurations.map(&:name) }.flatten.reduce({}) do |hash, name|
-            hash[name] = name == 'Debug' ? :debug : :release
-            hash
-          end.merge(target_definition.build_configurations || {})
-        else
-          target_definition.build_configurations || {}
-        end
-      end
-
-      # @return [Platform] The platform for the library.
-      #
-      # @note   This resolves to the lowest deployment target across the user
-      #         targets.
-      #
-      # @todo   Is assigning the platform to the target definition the best way
-      #         to go?
+      # @return [void]
       #
-      def compute_platform_for_target_definition(target_definition, user_targets)
-        return target_definition.platform if target_definition.platform
-        name = nil
-        deployment_target = nil
-
-        user_targets.each do |target|
-          name ||= target.platform_name
-          raise Informative, 'Targets with different platforms' unless name == target.platform_name
-          if !deployment_target || deployment_target > Version.new(target.deployment_target)
-            deployment_target = Version.new(target.deployment_target)
+      def verify_platforms_specified!
+        unless config.integrate_targets?
+          podfile.target_definition_list.each do |target_definition|
+            unless target_definition.platform
+              raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
+            end
           end
         end
-
-        target_definition.set_platform(name, deployment_target)
-        Platform.new(name, deployment_target)
-      end
-
-      # @return [Platform] The platform for the library.
-      #
-      # @note   This resolves to the lowest deployment target across the user
-      #         targets.
-      #
-      # @todo   Is assigning the platform to the target definition the best way
-      #         to go?
-      #
-      def compute_archs_for_target_definition(target_definition, user_targets)
-        archs = []
-        user_targets.each do |target|
-          target_archs = target.common_resolved_build_setting('ARCHS')
-          archs.concat(Array(target_archs))
-        end
-
-        archs = archs.compact.uniq.sort
-        UI.message('Using `ARCHS` setting to build architectures of ' \
-                   "target `#{target_definition.label}`: " \
-                   "(`#{archs.join('`, `')}`)")
-        archs.length > 1 ? archs : archs.first
       end
 
-      # Precompute the platforms for each target_definition in the Podfile
+      # Precompute information for each target_definition in the Podfile
       #
       # @note The platforms are computed and added to each target_definition
       #       because it might be necessary to infer the platform from the
       #       user targets.
       #
-      # @return [void]
+      # @return [Hash{TargetDefinition => TargetInspectionResult}]
       #
-      def compute_target_platforms
+      def inspect_targets_to_integrate
+        inspection_result = {}
         UI.section 'Inspecting targets to integrate' do
           podfile.target_definition_list.each do |target_definition|
-            if config.integrate_targets?
-              project_path = compute_user_project_path(target_definition)
-              user_project = Xcodeproj::Project.open(project_path)
-              targets = compute_user_project_targets(target_definition, user_project)
-              compute_platform_for_target_definition(target_definition, targets)
-              archs = compute_archs_for_target_definition(target_definition, targets)
-              @archs_by_target_def[target_definition] = archs
-            else
-              unless target_definition.platform
-                raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
-              end
-            end
+            inspector = TargetInspector.new(target_definition, config.installation_root)
+            results = inspector.compute_results
+            inspection_result[target_definition] = results
+            UI.message('Using `ARCHS` setting to build architectures of ' \
+              "target `#{target_definition.label}`: (`#{results.archs.join('`, `')}`)")
           end
         end
-      end
-
-      #-----------------------------------------------------------------------#
-
-      class AnalysisResult
-        # @return [SpecsState] the states of the Podfile specs.
-        #
-        attr_accessor :podfile_state
-
-        # @return [Hash{TargetDefinition => Array<Spec>}] the specifications
-        #         grouped by target.
-        #
-        attr_accessor :specs_by_target
-
-        # @return [Array<Specification>] the specifications of the resolved
-        #         version of Pods that should be installed.
-        #
-        attr_accessor :specifications
-
-        # @return [SpecsState] the states of the {Sandbox} respect the resolved
-        #         specifications.
-        #
-        attr_accessor :sandbox_state
-
-        # @return [Array<Target>] The Podfile targets containing library
-        #         dependencies.
-        #
-        attr_accessor :targets
-
-        # @return [Hash{String=>Symbol}] A hash representing all the user build
-        #         configurations across all integration targets. Each key
-        #         corresponds to the name of a configuration and its value to
-        #         its type (`:debug` or `:release`).
-        #
-        def all_user_build_configurations
-          targets.reduce({}) do |result, target|
-            result.merge(target.user_build_configurations)
-          end
-        end
-      end
-
-      #-----------------------------------------------------------------------#
-
-      # This class represents the state of a collection of Pods.
-      #
-      # @note The names of the pods stored by this class are always the **root**
-      #       name of the specification.
-      #
-      # @note The motivation for this class is to ensure that the names of the
-      #       subspecs are added instead of the name of the Pods.
-      #
-      class SpecsState
-        # Initialize a new instance
-        #
-        # @param  [Hash{Symbol=>String}] pods_by_state
-        #         The name of the pods grouped by their state
-        #         (`:added`, `:removed`, `:changed` or `:unchanged`).
-        #
-        def initialize(pods_by_state = nil)
-          @added     = []
-          @deleted   = []
-          @changed   = []
-          @unchanged = []
-
-          if pods_by_state
-            @added     = pods_by_state[:added]     || []
-            @deleted   = pods_by_state[:removed]   || []
-            @changed   = pods_by_state[:changed]   || []
-            @unchanged = pods_by_state[:unchanged] || []
-          end
-        end
-
-        # @return [Array<String>] the names of the pods that were added.
-        #
-        attr_accessor :added
-
-        # @return [Array<String>] the names of the pods that were changed.
-        #
-        attr_accessor :changed
-
-        # @return [Array<String>] the names of the pods that were deleted.
-        #
-        attr_accessor :deleted
-
-        # @return [Array<String>] the names of the pods that were unchanged.
-        #
-        attr_accessor :unchanged
-
-        # Displays the state of each pod.
-        #
-        # @return [void]
-        #
-        def print
-          added    .sort.each { |pod| UI.message('A'.green  + " #{pod}", '', 2) }
-          deleted  .sort.each { |pod| UI.message('R'.red    + " #{pod}", '', 2) }
-          changed  .sort.each { |pod| UI.message('M'.yellow + " #{pod}", '', 2) }
-          unchanged.sort.each { |pod| UI.message('-'        + " #{pod}", '', 2) }
-        end
-
-        # Adds the name of a Pod to the give state.
-        #
-        # @param  [String] name
-        #         the name of the Pod.
-        #
-        # @param  [Symbol] state
-        #         the state of the Pod.
-        #
-        # @return [void]
-        #
-        def add_name(name, state)
-          send(state) << name
-        end
+        inspection_result
       end
     end
   end