cocoapods 1.4.0 → 1.5.0.beta.1

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

@@ -55,12 +55,16 @@ module Pod
           includes_static_libs = !target.requires_frameworks?
           includes_static_libs ||= pod_targets.flat_map(&:file_accessors).any? { |fa| !fa.vendored_static_artifacts.empty? }
           config = {
+            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
+            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
+            'HEADER_SEARCH_PATHS' => '$(inherited) ',
+            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
+            'OTHER_CFLAGS' => '$(inherited) ',
             'OTHER_LDFLAGS' => '$(inherited) ' + XCConfigHelper.default_ld_flags(target, includes_static_libs),
+            'OTHER_SWIFT_FLAGS' => '$(inherited) ',
             'PODS_PODFILE_DIR_PATH' => target.podfile_dir_relative_path,
             'PODS_ROOT' => target.relative_pods_root,
-            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
-            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
-            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
+            'SWIFT_INCLUDE_PATHS' => '$(inherited) ',
           }.merge(embedded_content_settings)
 
           @xcconfig = Xcodeproj::Config.new(config)
@@ -139,13 +143,15 @@ module Pod
               "#{target.build_product_path}/Headers"
             end
             build_settings = {
+              # TODO: remove quote imports in CocoaPods 2.0
               # Make framework headers discoverable by `import "…"`
-              'OTHER_CFLAGS' => '$(inherited) ' + XCConfigHelper.quote(framework_header_search_paths, '-iquote'),
+              'OTHER_CFLAGS' => XCConfigHelper.quote(framework_header_search_paths, '-iquote'),
             }
             if pod_targets.any? { |t| !t.should_build? }
               # Make library headers discoverable by `#import "…"`
               library_header_search_paths = target.sandbox.public_headers.search_paths(target.platform)
-              build_settings['HEADER_SEARCH_PATHS'] = '$(inherited) ' + XCConfigHelper.quote(library_header_search_paths)
+              # TODO: remove quote imports in CocoaPods 2.0
+              build_settings['HEADER_SEARCH_PATHS'] = XCConfigHelper.quote(library_header_search_paths)
               build_settings['OTHER_CFLAGS'] += ' ' + XCConfigHelper.quote(library_header_search_paths, '-isystem')
             end
             build_settings
@@ -153,21 +159,22 @@ module Pod
             # Make headers discoverable from $PODS_ROOT/Headers directory
             header_search_paths = target.sandbox.public_headers.search_paths(target.platform)
             {
+              # TODO: remove quote imports in CocoaPods 2.0
               # by `#import "…"`
-              'HEADER_SEARCH_PATHS' => '$(inherited) ' + XCConfigHelper.quote(header_search_paths),
+              'HEADER_SEARCH_PATHS' => XCConfigHelper.quote(header_search_paths),
               # by `#import <…>`
-              'OTHER_CFLAGS' => '$(inherited) ' + XCConfigHelper.quote(header_search_paths, '-isystem'),
+              'OTHER_CFLAGS' => XCConfigHelper.quote(header_search_paths, '-isystem'),
             }
           end
         end
 
         private
 
-        # Add build settings, which ensure that the pod targets can be imported
-        # from the integrating target by all sort of imports, which are:
-        #  - `#import <…>`
-        #  - `#import "…"`
-        #  - `@import …;` / `import …`
+        # Add build settings, which ensure that the pod targets can be imported from the integrating target.
+        # For >= 1.5.0 we use modular (stricter) header search paths this means that the integrated target will only be
+        # able to import public headers using `<>` or `@import` notation, but never import any private headers.
+        #
+        # For < 1.5.0 legacy header search paths the same rules apply: It's the wild west.
         #
         def generate_settings_to_import_pod_targets
           @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(target, pod_targets)
@@ -176,7 +183,6 @@ module Pod
             generator = AggregateXCConfig.new(search_paths_target, configuration_name)
             @xcconfig.merge! XCConfigHelper.search_paths_for_dependent_targets(nil, search_paths_target.pod_targets)
             @xcconfig.merge!(generator.settings_to_import_pod_targets)
-
             # Propagate any HEADER_SEARCH_PATHS settings from the search paths.
             XCConfigHelper.propagate_header_search_paths_from_search_paths(search_paths_target, @xcconfig)
           end

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

@@ -44,22 +44,20 @@ module Pod
         # @return [Xcodeproj::Config]
         #
         def generate
-          target_search_paths = target.build_headers.search_paths(target.platform)
-          sandbox_search_paths = target.sandbox.public_headers.search_paths(target.platform)
-          search_paths = target_search_paths.concat(sandbox_search_paths).uniq
-
           config = {
             'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
             'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
-            'HEADER_SEARCH_PATHS' => XCConfigHelper.quote(search_paths),
+            'HEADER_SEARCH_PATHS' => '$(inherited) ' + XCConfigHelper.quote(target.header_search_paths(@test_xcconfig)),
             'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
+            'OTHER_CFLAGS' => '$(inherited) ',
             'OTHER_LDFLAGS' => XCConfigHelper.default_ld_flags(target, @test_xcconfig),
+            'OTHER_SWIFT_FLAGS' => '$(inherited) ',
             'PODS_ROOT' => '${SRCROOT}',
             'PODS_TARGET_SRCROOT' => target.pod_target_srcroot,
             'PRODUCT_BUNDLE_IDENTIFIER' => 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}',
             'SKIP_INSTALL' => 'YES',
             'SWIFT_ACTIVE_COMPILATION_CONDITIONS' => '$(inherited) ',
-            # 'USE_HEADERMAP' => 'NO'
+            'SWIFT_INCLUDE_PATHS' => '$(inherited) ',
           }
 
           @xcconfig = Xcodeproj::Config.new(config)

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

@@ -140,8 +140,7 @@ module Pod
         #
         def self.links_dependency?(aggregate_target, pod_target)
           return true if aggregate_target.nil? || aggregate_target.target_definition.inheritance == 'complete'
-          targets = aggregate_target.pod_targets - aggregate_target.search_paths_aggregate_targets.flat_map(&:pod_targets)
-          targets.include?(pod_target)
+          aggregate_target.pod_targets_to_link.include?(pod_target)
         end
 
         # Adds build settings for dynamic vendored frameworks and libraries.
@@ -329,19 +328,43 @@ module Pod
             build_settings['CONFIGURATION_BUILD_DIR'] = target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
           end
 
+          module_map_files = []
           unless dependent_targets.empty?
             framework_search_paths = []
             library_search_paths = []
+            swift_import_paths = []
             dependent_targets.each do |dependent_target|
               if dependent_target.requires_frameworks?
                 framework_search_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
               else
                 library_search_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE)
+                if dependent_target.defines_module?
+                  module_map_file = if dependent_target.uses_swift?
+                                      # for swift, we have a custom build phase that copies in the module map, appending the .Swift module
+                                      "${PODS_CONFIGURATION_BUILD_DIR}/#{dependent_target.label}/#{dependent_target.product_module_name}.modulemap"
+                                    else
+                                      "${PODS_ROOT}/#{dependent_target.module_map_path.relative_path_from(dependent_target.sandbox.root)}"
+                                    end
+                  module_map_files << %(-fmodule-map-file="#{module_map_file}")
+                  swift_import_paths << dependent_target.configuration_build_dir(CONFIGURATION_BUILD_DIR_VARIABLE) if dependent_target.uses_swift?
+                end
               end
             end
+
             build_settings['FRAMEWORK_SEARCH_PATHS'] = XCConfigHelper.quote(framework_search_paths.uniq)
             build_settings['LIBRARY_SEARCH_PATHS']   = XCConfigHelper.quote(library_search_paths.uniq)
+            build_settings['SWIFT_INCLUDE_PATHS']    = XCConfigHelper.quote(swift_import_paths.uniq)
+          end
+
+          other_swift_flags = module_map_files.tap(&:uniq!).flat_map { |f| ['-Xcc', f] }
+          if target.is_a?(PodTarget) && !target.requires_frameworks? && target.defines_module?
+            # make it possible for a mixed swift/objc static library to be able to import the objc from within swift
+            other_swift_flags += ['-import-underlying-module', '-Xcc', '-fmodule-map-file="${SRCROOT}/${MODULEMAP_FILE}"']
           end
+          # unconditionally set these, because of (the possibility of) having to add the pod targets own module map file
+          build_settings['OTHER_CFLAGS']           = module_map_files.join(' ')
+          build_settings['OTHER_SWIFT_FLAGS']      = other_swift_flags.join(' ')
+
           build_settings
         end
 

data/lib/cocoapods/installer.rb

@@ -219,8 +219,8 @@ module Pod
     #         generated as result of the analyzer.
     #
     def pod_targets
-      aggregate_target_pod_targets = aggregate_targets.map(&:pod_targets).flatten
-      test_dependent_targets = aggregate_target_pod_targets.map(&:test_dependent_targets).flatten
+      aggregate_target_pod_targets = aggregate_targets.flat_map(&:pod_targets)
+      test_dependent_targets = aggregate_target_pod_targets.flat_map(&:test_dependent_targets)
       (aggregate_target_pod_targets + test_dependent_targets).uniq
     end
 
@@ -321,8 +321,17 @@ module Pod
       root_specs.sort_by(&:name).each do |spec|
         if pods_to_install.include?(spec.name)
           if sandbox_state.changed.include?(spec.name) && sandbox.manifest
-            previous = sandbox.manifest.version(spec.name)
-            title = "Installing #{spec.name} #{spec.version} (was #{previous})"
+            current_version = spec.version
+            previous_version = sandbox.manifest.version(spec.name)
+            has_changed_version = current_version != previous_version
+            current_repo = analysis_result.specs_by_source.detect { |key, values| break key if values.map(&:name).include?(spec.name) }
+            current_repo &&= current_repo.url || current_repo.name
+            previous_spec_repo = sandbox.manifest.spec_repo(spec.name)
+            has_changed_repo = !previous_spec_repo.nil? && current_repo && (current_repo != previous_spec_repo)
+            title = "Installing #{spec.name} #{spec.version}"
+            title << " (was #{previous_version} and source changed to `#{current_repo}` from `#{previous_spec_repo}`)" if has_changed_version && has_changed_repo
+            title << " (was #{previous_version})" if has_changed_version && !has_changed_repo
+            title << " (source changed to `#{current_repo}` from `#{previous_spec_repo}`)" if !has_changed_version && has_changed_repo
           else
             title = "Installing #{spec}"
           end
@@ -429,7 +438,7 @@ module Pod
     end
 
     def print_post_install_message
-      podfile_dependencies = podfile.dependencies.uniq.size
+      podfile_dependencies = analysis_result.podfile_dependency_cache.podfile_dependencies.size
       pods_installed = root_specs.size
       title_options = { :verbose_prefix => '-> '.green }
       UI.titled_section('Pod installation complete! ' \
@@ -548,9 +557,9 @@ module Pod
     # @return [void]
     #
     def write_lockfiles
-      external_source_pods = podfile.dependencies.select(&:external_source).map(&:root_name).uniq
+      external_source_pods = analysis_result.podfile_dependency_cache.podfile_dependencies.select(&:external_source).map(&:root_name).uniq
       checkout_options = sandbox.checkout_sources.select { |root_name, _| external_source_pods.include? root_name }
-      @lockfile = Lockfile.generate(podfile, analysis_result.specifications, checkout_options)
+      @lockfile = Lockfile.generate(podfile, analysis_result.specifications, checkout_options, analysis_result.specs_by_source)
 
       UI.message "- Writing Lockfile in #{UI.path config.lockfile_path}" do
         @lockfile.write_to_disk(config.lockfile_path)
@@ -651,7 +660,7 @@ module Pod
     #
     def development_pod_targets
       pod_targets.select do |pod_target|
-        sandbox.development_pods.keys.include?(pod_target.pod_name)
+        sandbox.local?(pod_target.pod_name)
       end
     end
 

data/lib/cocoapods/installer/analyzer.rb

@@ -10,11 +10,12 @@ module Pod
       delegate_installation_options { podfile }
 
       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 :PodfileDependencyCache,    'cocoapods/installer/analyzer/podfile_dependency_cache'
       autoload :PodVariant,                'cocoapods/installer/analyzer/pod_variant'
       autoload :PodVariantSet,             'cocoapods/installer/analyzer/pod_variant_set'
+      autoload :SandboxAnalyzer,           'cocoapods/installer/analyzer/sandbox_analyzer'
+      autoload :SpecsState,                'cocoapods/installer/analyzer/specs_state'
       autoload :TargetInspectionResult,    'cocoapods/installer/analyzer/target_inspection_result'
       autoload :TargetInspector,           'cocoapods/installer/analyzer/target_inspector'
 
@@ -54,6 +55,7 @@ module Pod
         @has_dependencies = true
         @test_pod_target_analyzer_cache = {}
         @test_pod_target_key = Struct.new(:name, :pod_targets)
+        @podfile_dependency_cache = PodfileDependencyCache.from_podfile(podfile)
       end
 
       # Performs the analysis.
@@ -71,6 +73,7 @@ module Pod
         validate_podfile!
         validate_lockfile_version!
         @result = AnalysisResult.new
+        @result.podfile_dependency_cache = @podfile_dependency_cache
         if installation_options.integrate_targets?
           @result.target_inspections = inspect_targets_to_integrate
         else
@@ -90,6 +93,8 @@ module Pod
         @result.specs_by_target = resolver_specs_by_target.each_with_object({}) do |rspecs_by_target, hash|
           hash[rspecs_by_target[0]] = rspecs_by_target[1].map(&:spec)
         end
+        @result.specs_by_source = Hash[resolver_specs_by_target.values.flatten(1).group_by(&:source).map { |source, specs| [source, specs.map(&:spec).uniq] }]
+        sources.each { |s| @result.specs_by_source[s] ||= [] }
         @result
       end
 
@@ -184,7 +189,7 @@ module Pod
       alias_method :specs_updated?, :specs_updated
 
       def validate_podfile!
-        validator = Installer::PodfileValidator.new(podfile)
+        validator = Installer::PodfileValidator.new(podfile, @podfile_dependency_cache)
         validator.validate
 
         unless validator.valid?
@@ -232,7 +237,7 @@ module Pod
           pods_state
         else
           state = SpecsState.new
-          state.added.merge(podfile.dependencies.map(&:root_name))
+          state.added.merge(@podfile_dependency_cache.podfile_dependencies.map(&:root_name))
           state
         end
       end
@@ -335,18 +340,18 @@ module Pod
         end
 
         unless embedded_targets_missing_hosts.empty?
-          embedded_targets_missing_hosts_product_types = Set.new embedded_targets_missing_hosts.map(&:user_targets).flatten.map(&:symbol_type)
+          embedded_targets_missing_hosts_product_types = Set.new embedded_targets_missing_hosts.flat_map(&:user_targets).map(&:symbol_type)
+          target_names = embedded_targets_missing_hosts.map do |target|
+            target.name.sub('Pods-', '') # Make the target names more recognizable to the user
+          end.join ', '
           #  If the targets missing hosts are only frameworks, then this is likely
           #  a project for doing framework development. In that case, just warn that
           #  the frameworks that these targets depend on won't be integrated anywhere
           if embedded_targets_missing_hosts_product_types.subset?(Set.new([:framework, :static_library]))
-            UI.warn 'The Podfile contains framework or static library targets, for which the Podfile does not contain host targets (targets which embed the framework).' \
+            UI.warn "The Podfile contains framework or static library targets (#{target_names}), for which the Podfile does not contain host targets (targets which embed the framework)." \
               "\n" \
               'If this project is for doing framework development, you can ignore this message. Otherwise, add a target to the Podfile that embeds these frameworks to make this message go away (e.g. a test target).'
           else
-            target_names = embedded_targets_missing_hosts.map do |target|
-              target.name.sub('Pods-', '') # Make the target names more recognizable to the user
-            end.join ', '
             raise Informative, "Unable to find host target(s) for #{target_names}. Please add the host targets for the embedded targets to the Podfile." \
                                 "\n" \
                                 'Certain kinds of targets require a host target. A host target is a "parent" target which embeds a "child" target. These are example types of targets that need a host target:' \
@@ -393,8 +398,7 @@ module Pod
           embedded_targets = aggregate_targets.select(&:requires_host_target?)
           analyze_host_targets_in_podfile(aggregate_targets, embedded_targets)
 
-          use_frameworks_embedded_targets = embedded_targets.select(&:requires_frameworks?)
-          non_use_frameworks_embedded_targets = embedded_targets.reject(&:requires_frameworks?)
+          use_frameworks_embedded_targets, non_use_frameworks_embedded_targets = embedded_targets.partition(&:requires_frameworks?)
           aggregate_targets.each do |target|
             # For targets that require frameworks, we always have to copy their pods to their
             # host targets because those frameworks will all be loaded from the host target's bundle
@@ -406,9 +410,9 @@ module Pod
           end
         end
         aggregate_targets.each do |target|
-          target.search_paths_aggregate_targets = aggregate_targets.select do |aggregate_target|
+          target.search_paths_aggregate_targets.concat(aggregate_targets.select do |aggregate_target|
             target.target_definition.targets_to_inherit_search_paths.include?(aggregate_target.target_definition)
-          end
+          end).freeze
         end
       end
 
@@ -510,8 +514,9 @@ module Pod
             hash[name] = values.sort_by { |pt| pt.specs.count }
           end
           pod_targets.each do |target|
-            dependencies = transitive_dependencies_for_specs(target.specs.reject(&:test_specification?), target.platform, all_resolver_specs).group_by(&:root)
-            test_dependencies = transitive_dependencies_for_specs(target.specs.select(&:test_specification?), target.platform, all_resolver_specs).group_by(&:root)
+            all_specs = all_resolver_specs.to_set
+            dependencies = transitive_dependencies_for_specs(target.non_test_specs.to_set, target.platform, all_specs).group_by(&:root)
+            test_dependencies = transitive_dependencies_for_specs(target.test_specs.to_set, target.platform, all_specs).group_by(&:root)
             test_dependencies.delete_if { |k| dependencies.key? k }
             target.dependent_targets = filter_dependencies(dependencies, pod_targets_by_name, target)
             target.test_dependent_targets = filter_dependencies(test_dependencies, pod_targets_by_name, target)
@@ -525,8 +530,9 @@ module Pod
             end
 
             pod_targets.each do |target|
-              dependencies = transitive_dependencies_for_specs(target.specs.reject(&:test_specification?), target.platform, specs.map(&:spec)).group_by(&:root)
-              test_dependencies = transitive_dependencies_for_specs(target.specs.select(&:test_specification?), target.platform, specs.map(&:spec)).group_by(&:root)
+              all_specs = specs.map(&:spec).to_set
+              dependencies = transitive_dependencies_for_specs(target.non_test_specs.to_set, target.platform, all_specs).group_by(&:root)
+              test_dependencies = transitive_dependencies_for_specs(target.test_specs.to_set, target.platform, all_specs).group_by(&:root)
               test_dependencies.delete_if { |k| dependencies.key? k }
               target.dependent_targets = pod_targets.reject { |t| dependencies[t.root_spec].nil? }
               target.test_dependent_targets = pod_targets.reject { |t| test_dependencies[t.root_spec].nil? }
@@ -564,16 +570,22 @@ module Pod
       #
       def transitive_dependencies_for_specs(specs, platform, all_specs)
         return [] if specs.empty? || all_specs.empty?
-        dependent_specs = specs.flat_map do |spec|
-          spec.consumer(platform).dependencies.flat_map do |dependency|
-            all_specs.find do |s|
+
+        dependent_specs = Set.new
+        specs.each do |spec|
+          spec.consumer(platform).dependencies.each do |dependency|
+            match = all_specs.find do |s|
+              next false unless s.name == dependency.name
               next false if specs.include?(s)
-              s.name == dependency.name
+              true
             end
-          end.compact
-        end.uniq
+            dependent_specs << match if match
+          end
+        end
+
         remaining_specs = all_specs - dependent_specs
-        dependent_specs + transitive_dependencies_for_specs(dependent_specs, platform, remaining_specs)
+
+        dependent_specs.union transitive_dependencies_for_specs(dependent_specs, platform, remaining_specs)
       end
 
       # Create a target for each spec group
@@ -624,7 +636,7 @@ module Pod
         else
           pods_to_update = result.podfile_state.changed + result.podfile_state.deleted
           pods_to_update += update[:pods] if update_mode == :selected
-          local_pod_names = podfile.dependencies.select(&:local?).map(&:root_name)
+          local_pod_names = @podfile_dependency_cache.podfile_dependencies.select(&:local?).map(&:root_name)
           pods_to_unlock = local_pod_names.reject do |pod_name|
             sandbox.specification(pod_name).checksum == lockfile.checksum(pod_name)
           end
@@ -665,7 +677,7 @@ module Pod
       end
 
       def verify_no_pods_with_different_sources!
-        deps_with_different_sources = podfile.dependencies.group_by(&:root_name).
+        deps_with_different_sources = @podfile_dependency_cache.podfile_dependencies.group_by(&:root_name).
           select { |_root_name, dependencies| dependencies.map(&:external_source).uniq.count > 1 }
         deps_with_different_sources.each do |root_name, dependencies|
           raise Informative, 'There are multiple dependencies with different ' \
@@ -688,7 +700,7 @@ module Pod
       def dependencies_to_fetch
         @deps_to_fetch ||= begin
           deps_to_fetch = []
-          deps_with_external_source = podfile.dependencies.select(&:external_source)
+          deps_with_external_source = @podfile_dependency_cache.podfile_dependencies.select(&:external_source)
 
           if update_mode == :all
             deps_to_fetch = deps_with_external_source
@@ -721,7 +733,7 @@ module Pod
           elsif update_mode == :all
             pods_to_fetch += result.podfile_state.unchanged + result.podfile_state.deleted
           end
-          pods_to_fetch += podfile.dependencies.
+          pods_to_fetch += @podfile_dependency_cache.podfile_dependencies.
             select { |dep| Hash(dep.external_source).key?(:podspec) && sandbox.specification_path(dep.root_name).nil? }.
             map(&:root_name)
           pods_to_fetch
@@ -729,7 +741,7 @@ module Pod
       end
 
       def store_existing_checkout_options
-        podfile.dependencies.select(&:external_source).each do |dep|
+        @podfile_dependency_cache.podfile_dependencies.select(&:external_source).each do |dep|
           if checkout_options = lockfile && lockfile.checkout_options_for_pod_named(dep.root_name)
             sandbox.store_checkout_source(dep.root_name, checkout_options)
           end
@@ -756,7 +768,7 @@ module Pod
       #         grouped by target.
       #
       def resolve_dependencies
-        duplicate_dependencies = podfile.dependencies.group_by(&:name).
+        duplicate_dependencies = @podfile_dependency_cache.podfile_dependencies.group_by(&:name).
           select { |_name, dependencies| dependencies.count > 1 }
         duplicate_dependencies.each do |name, dependencies|
           UI.warn "There are duplicate dependencies on `#{name}` in #{UI.path podfile.defined_in_file}:\n\n" \
@@ -765,8 +777,7 @@ module Pod
 
         resolver_specs_by_target = nil
         UI.section "Resolving dependencies of #{UI.path(podfile.defined_in_file) || 'Podfile'}" do
-          resolver = Resolver.new(sandbox, podfile, locked_dependencies, sources)
-          resolver.specs_updated = specs_updated?
+          resolver = Resolver.new(sandbox, podfile, locked_dependencies, sources, specs_updated?)
           resolver_specs_by_target = resolver.resolve
           resolver_specs_by_target.values.flatten(1).map(&:spec).each(&:validate_cocoapods_version)
         end
@@ -847,8 +858,8 @@ module Pod
           plugin_sources = @plugin_sources || []
 
           # Add any sources specified using the :source flag on individual dependencies.
-          dependency_sources = podfile.dependencies.map(&:podspec_repo).compact
-          all_dependencies_have_sources = dependency_sources.count == podfile.dependencies.count
+          dependency_sources = @podfile_dependency_cache.podfile_dependencies.map(&:podspec_repo).compact
+          all_dependencies_have_sources = dependency_sources.count == @podfile_dependency_cache.podfile_dependencies.count
 
           if all_dependencies_have_sources
             sources = dependency_sources
@@ -880,7 +891,7 @@ module Pod
       #
       def verify_platforms_specified!
         unless installation_options.integrate_targets?
-          podfile.target_definition_list.each do |target_definition|
+          @podfile_dependency_cache.target_definition_list.each do |target_definition|
             if !target_definition.empty? && target_definition.platform.nil?
               raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
             end
@@ -899,7 +910,7 @@ module Pod
       def inspect_targets_to_integrate
         inspection_result = {}
         UI.section 'Inspecting targets to integrate' do
-          inspectors = podfile.target_definition_list.map do |target_definition|
+          inspectors = @podfile_dependency_cache.target_definition_list.map do |target_definition|
             next if target_definition.abstract?
             TargetInspector.new(target_definition, config.installation_root)
           end.compact
@@ -907,8 +918,7 @@ module Pod
             project = Xcodeproj::Project.open(project_path)
             target_inspectors.each do |inspector|
               target_definition = inspector.target_definition
-              inspector.user_project = project
-              results = inspector.compute_results
+              results = inspector.compute_results(project)
               inspection_result[target_definition] = results
               UI.message('Using `ARCHS` setting to build architectures of ' \
                 "target `#{target_definition.label}`: (`#{results.archs.join('`, `')}`)")