Merge pull request #3550 from CocoaPods/mr-deduplicate-frameworks

Deduplicate pod targets

CHANGELOG.md

@@ -6,6 +6,25 @@ To install release candidates run `[sudo] gem install cocoapods --pre`
 
 ## Master
 
+##### Highlighted Enhancement That Needs Testing
+
+* De-duplicate Pod Targets: CocoaPods now recognizes when a dependency is used
+  multiple times across different user targets, but needs to be built only once.
+  The targets in `Pods.xcodeproj` need to be duplicated when one of the following
+  applies:
+  * They are used on different platforms.
+  * They are used with differents sets of subspecs.
+  * They have any dependency which needs to be duplicated.
+
+  You can opt-out of this behavior installation-wise, by setting the following
+  option in your ``~/.cocoapods/config.yaml`:
+  ```yaml
+  deduplicate_targets: false
+  ```
+
+  [Marius Rackwitz](https://github.com/mrackwitz)
+  [#3550](https://github.com/CocoaPods/CocoaPods/issues/3550)
+
 ##### Breaking
 
 * The CocoaPods environment header has been removed.  

lib/cocoapods/config.rb

@@ -19,6 +19,7 @@ module Pod
 
       :clean               => true,
       :integrate_targets   => true,
+      :deduplicate_targets => true,
       :lock_pod_source     => true,
       :new_version_message => ENV['COCOAPODS_SKIP_UPDATE_MESSAGE'].nil?,
 
@@ -89,6 +90,11 @@ module Pod
     attr_accessor :integrate_targets
     alias_method :integrate_targets?, :integrate_targets
 
+    # @return [Bool] Whether CocoaPods should deduplicate pod targets.
+    #
+    attr_accessor :deduplicate_targets
+    alias_method :deduplicate_targets?, :deduplicate_targets
+
     # @return [Bool] Whether the installer should skip the repos update.
     #
     attr_accessor :skip_repo_update

lib/cocoapods/generator/embed_frameworks_script.rb

 module Pod
   module Generator
     class EmbedFrameworksScript
-      # @return [TargetDefinition] The target definition, whose label will be
-      #         used to locate the target-specific build products.
-      #
-      attr_reader :target_definition
-
-      # @return [Hash{String, Array{String}] Multiple lists of frameworks per
+      # @return [Hash{String => Array<String>}] Multiple lists of frameworks per
       #         configuration.
       #
       attr_reader :frameworks_by_config
 
-      # @param  [TargetDefinition] target_definition
-      #         @see #target_definition
-      #
-      # @param  [Hash{String, Array{String}] frameworks_by_config
+      # @param  [Hash{String => Array<String>] frameworks_by_config
       #         @see #frameworks_by_config
       #
-      def initialize(target_definition, frameworks_by_config)
-        @target_definition = target_definition
+      def initialize(frameworks_by_config)
         @frameworks_by_config = frameworks_by_config
       end
 
@@ -54,7 +45,7 @@ module Pod
 
           install_framework()
           {
-            local source="${BUILT_PRODUCTS_DIR}/#{target_definition.label}/$1"
+            local source="${BUILT_PRODUCTS_DIR}/$1"
             local destination="${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
 
             if [ -L "${source}" ]; then
@@ -72,9 +63,9 @@ module Pod
 
             # Embed linked Swift runtime libraries
             local basename
-            basename=$(echo $1 | sed -E s/\\\\..+// && exit ${PIPESTATUS[0]})
+            basename=$(basename $1 | sed -E s/\\\\..+// && exit ${PIPESTATUS[0]})
             local swift_runtime_libs
-            swift_runtime_libs=$(xcrun otool -LX "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/$1/${basename}" | grep --color=never @rpath/libswift | sed -E s/@rpath\\\\/\\(.+dylib\\).*/\\\\1/g | uniq -u  && exit ${PIPESTATUS[0]})
+            swift_runtime_libs=$(xcrun otool -LX "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/${basename}.framework/${basename}" | grep --color=never @rpath/libswift | sed -E s/@rpath\\\\/\\(.+dylib\\).*/\\\\1/g | uniq -u  && exit ${PIPESTATUS[0]})
             for lib in $swift_runtime_libs; do
               echo "rsync -auv \\"${SWIFT_STDLIB_PATH}/${lib}\\" \\"${destination}\\""
               rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"

lib/cocoapods/generator/umbrella_header.rb

@@ -18,7 +18,7 @@ module Pod
       #         @see target
       #
       def initialize(target)
-        super(target.target_definition.platform)
+        super(target.platform)
         @target = target
       end
 

lib/cocoapods/generator/xcconfig/aggregate_xcconfig.rb

@@ -54,19 +54,57 @@ module Pod
             'PODS_ROOT' => target.relative_pods_root,
             'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
           }
+          @xcconfig = Xcodeproj::Config.new(config)
+
+          @xcconfig.merge!(merged_user_target_xcconfigs)
+
+          generate_settings_to_import_pod_targets
+
+          XCConfigHelper.add_target_specific_settings(target, @xcconfig)
+
+          generate_vendored_build_settings
+          generate_other_ld_flags
+
+          # TODO: Need to decide how we are going to ensure settings like these
+          # are always excluded from the user's project.
+          #
+          # See https://github.com/CocoaPods/CocoaPods/issues/1216
+          @xcconfig.attributes.delete('USE_HEADERMAP')
 
+          generate_ld_runpath_search_paths if target.requires_frameworks?
+
+          @xcconfig
+        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 …`
+        #
+        def generate_settings_to_import_pod_targets
           if target.requires_frameworks?
             # Framework headers are automatically discoverable by `#import <…>`.
-            header_search_paths = pod_targets.map { |target| "$PODS_FRAMEWORK_BUILD_PATH/#{target.product_name}/Headers" }
+            header_search_paths = target.pod_targets.map do |target|
+              if target.scoped?
+                "$PODS_FRAMEWORK_BUILD_PATH/#{target.product_name}/Headers"
+              else
+                "$CONFIGURATION_BUILD_DIR/#{target.product_name}/Headers"
+              end
+            end
             build_settings = {
-              'PODS_FRAMEWORK_BUILD_PATH' => target.configuration_build_dir,
+              'PODS_FRAMEWORK_BUILD_PATH' => target.scoped_configuration_build_dir,
               # Make headers discoverable by `import "…"`
               'OTHER_CFLAGS' => '$(inherited) ' + XCConfigHelper.quote(header_search_paths, '-iquote'),
             }
-            if target.pod_targets.any?(&:should_build?)
+            if target.pod_targets.any? { |t| t.should_build? && t.scoped? }
               build_settings['FRAMEWORK_SEARCH_PATHS'] = '$(inherited) "$PODS_FRAMEWORK_BUILD_PATH"'
             end
-            config.merge!(build_settings)
+            @xcconfig.merge!(build_settings)
           else
             # Make headers discoverable from $PODS_ROOT/Headers directory
             header_search_paths = target.sandbox.public_headers.search_paths(target.platform)
@@ -76,46 +114,50 @@ module Pod
               # by `#import <…>`
               'OTHER_CFLAGS' => '$(inherited) ' + XCConfigHelper.quote(header_search_paths, '-isystem'),
             }
-            config.merge!(build_settings)
+            @xcconfig.merge!(build_settings)
           end
+        end
 
-          @xcconfig = Xcodeproj::Config.new(config)
-
-          XCConfigHelper.add_target_specific_settings(target, @xcconfig)
-
-          pod_targets.each do |pod_target|
+        # Add custom build settings and required build settings to link to
+        # vendored libraries and frameworks.
+        #
+        # @note
+        #   In case of generated pod targets, which require frameworks, the
+        #   vendored frameworks and libraries are already linked statically
+        #   into the framework binary and must not be linked again to the
+        #   user target.
+        #
+        def generate_vendored_build_settings
+          target.pod_targets.each do |pod_target|
             unless pod_target.should_build? && pod_target.requires_frameworks?
-              # In case of generated pod targets, which require frameworks, the
-              # vendored frameworks and libraries are already linked statically
-              # into the framework binary and must not be linked again to the
-              # user target.
               XCConfigHelper.add_settings_for_file_accessors_of_target(pod_target, @xcconfig)
             end
+          end
+        end
 
-            # Add pod target to list of frameworks / libraries that are
-            # linked with the user’s project.
-            if pod_target.should_build?
-              if pod_target.requires_frameworks?
-                @xcconfig.merge!('OTHER_LDFLAGS' => %(-framework "#{pod_target.product_basename}"))
-              else
-                @xcconfig.merge!('OTHER_LDFLAGS' => %(-l "#{pod_target.product_basename}"))
-              end
+        # Add pod target to list of frameworks / libraries that are linked
+        # with the user’s project.
+        #
+        def generate_other_ld_flags
+          other_ld_flags = target.pod_targets.select(&:should_build?).map do |pod_target|
+            if pod_target.requires_frameworks?
+              %(-framework "#{pod_target.product_basename}")
+            else
+              %(-l "#{pod_target.product_basename}")
             end
           end
 
-          @xcconfig.merge!(merged_user_target_xcconfigs)
-
-          # TODO: Need to decide how we are going to ensure settings like these
-          # are always excluded from the user's project.
-          #
-          # See https://github.com/CocoaPods/CocoaPods/issues/1216
-          @xcconfig.attributes.delete('USE_HEADERMAP')
-
-          generate_ld_runpath_search_paths if target.requires_frameworks?
-
-          @xcconfig
+          @xcconfig.merge!('OTHER_LDFLAGS' => other_ld_flags.join(' '))
         end
 
+        # Ensure to add the default linker run path search paths as they could
+        # be not present due to being historically absent in the project or
+        # target template or just being removed by being superficial when
+        # linking third-party dependencies exclusively statically. This is not
+        # something a project needs specifically for the integration with
+        # CocoaPods, but makes sure that it is self-contained for the given
+        # constraints.
+        #
         def generate_ld_runpath_search_paths
           ld_runpath_search_paths = ['$(inherited)']
           if target.platform.symbolic_name == :osx

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

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

lib/cocoapods/installer.rb

@@ -179,7 +179,7 @@ module Pod
     #         generated as result of the analyzer.
     #
     def pod_targets
-      aggregate_targets.map(&:pod_targets).flatten
+      aggregate_targets.map(&:pod_targets).flatten.uniq
     end
 
     # @return [Array<Specification>] The specifications that where installed.
@@ -212,9 +212,11 @@ module Pod
     # @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
@@ -260,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
 
@@ -351,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
@@ -537,7 +537,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
@@ -628,12 +628,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
 
@@ -740,6 +736,19 @@ module Pod
 
     #-------------------------------------------------------------------------#
 
+    public
+
+    # @return [Array<Library>] The targets of the development pods generated by
+    #         the installation process.
+    #
+    def development_pod_targets
+      pod_targets.select do |pod_target|
+        sandbox.development_pods.keys.include?(pod_target.pod_name)
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
     private
 
     # @!group Private helpers

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.
@@ -55,7 +57,11 @@ module Pod
         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
 
@@ -213,16 +219,15 @@ module Pod
 
       private
 
-      # Creates the models that represent the libraries generated by CocoaPods.
+      # 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
@@ -230,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 = []
@@ -259,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
@@ -553,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.
-      #
-      # @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.
+      # Checks whether the platform is specified if not integrating
       #
-      # @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

lib/cocoapods/installer/analyzer/analysis_result.rb

+module Pod
+  class Installer
+    class Analyzer
+      class AnalysisResult
+        # @return [SpecsState] the states of the Podfile specs.
+        #
+        attr_accessor :podfile_state
+
+        # @return [Hash{TargetDefinition => Array<Specification>}] 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{TargetDefinition => Array<TargetInspectionResult>}] the
+        #         results of inspecting the user targets
+        attr_accessor :target_inspections
+
+        # @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
+    end
+  end
+end

lib/cocoapods/installer/analyzer/specs_state.rb

+module Pod
+  class Installer
+    class Analyzer
+      # 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
+      end
+    end
+  end
+end

lib/cocoapods/installer/analyzer/target_inspection_result.rb

+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspectionResult
+        # @return [TargetDefinition] the target definition, whose project was
+        #         inspected
+        #
+        attr_accessor :target_definition
+
+        # @return [Pathname] the path of the user project that the
+        #         #target_definition should integrate
+        #
+        attr_accessor :project_path
+
+        # @return [Array<String>] the uuid of the user's targets
+        #
+        attr_accessor :project_target_uuids
+
+        # @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`).
+        #
+        attr_accessor :build_configurations
+
+        # @return [Platform] the platform of the user targets
+        #
+        attr_accessor :platform
+
+        # @return [Array<String>] the architectures used by user's targets
+        #
+        attr_accessor :archs
+
+        # @return [Bool] whether frameworks are recommended for the integration
+        #         due to the presence of Swift source in the user's targets
+        #
+        attr_accessor :recommends_frameworks
+      end
+    end
+  end
+end

lib/cocoapods/installer/analyzer/target_inspector.rb

+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspector
+        # @return [TargetDefinition] the target definition to inspect
+        #
+        attr_accessor :target_definition
+
+        # @return [Pathname] the root of the CocoaPods installation where the
+        #         Podfile is located
+        attr_accessor :installation_root
+
+        # Initialize a new instance
+        #
+        # @param [TargetDefinition] target_definition
+        #        @see #target_definition
+        #
+        # @param [Pathname] installation_root
+        #        @see #installation_root
+        #
+        def initialize(target_definition, installation_root)
+          @target_definition = target_definition
+          @installation_root = installation_root
+        end
+
+        # Inspect the #target_definition
+        #
+        # @return [TargetInspectionResult]
+        #
+        def compute_results
+          project_path = compute_project_path
+          user_project = Xcodeproj::Project.open(project_path)
+          targets = compute_targets(user_project)
+
+          result = TargetInspectionResult.new
+          result.target_definition = target_definition
+          result.project_path = project_path
+          result.project_target_uuids = targets.map(&:uuid)
+          result.build_configurations = compute_build_configurations(targets)
+          result.platform = compute_platform(targets)
+          result.archs = compute_archs(targets)
+          result
+        end
+
+        #-----------------------------------------------------------------------#
+
+        private
+
+        # Returns the path of the user project that the #target_definition
+        # 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_project_path
+          if target_definition.user_project_path
+            path = 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 = 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 #target_definition
+        # that needs to be integrated.
+        #
+        # @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).
+        #
+        # @param  [Xcodeproj::Project] user_project
+        #         the user project
+        #
+        # @return [Array<PBXNativeTarget>]
+        #
+        def compute_targets(user_project)
+          native_targets = user_project.native_targets
+          if link_with = target_definition.link_with
+            targets = native_targets.select { |t| link_with.include?(t.name) }
+            raise Informative, "Unable to find the targets named #{link_with.map { |x| "`#{x}`" }.to_sentence}" \
+              "to link with target definition `#{target_definition.name}`" if targets.empty?
+          elsif target_definition.link_with_first_target?
+            targets = [native_targets.first].compact
+            raise Informative, 'Unable to find a target' if targets.empty?
+          else
+            target = native_targets.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
+
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @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_build_configurations(user_targets)
+          if user_targets
+            user_targets.flat_map { |t| t.build_configurations.map(&:name) }.each_with_object({}) do |name, hash|
+              hash[name] = name == 'Debug' ? :debug : :release
+            end.merge(target_definition.build_configurations || {})
+          else
+            target_definition.build_configurations || {}
+          end
+        end
+
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @return [Platform] The platform of the user's targets
+        #
+        # @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_platform(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)
+            end
+          end
+
+          target_definition.set_platform(name, deployment_target)
+          Platform.new(name, deployment_target)
+        end
+
+        # Computes the architectures relevant for the user's targets.
+        #
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @return [Array<String>]
+        #
+        def compute_archs(user_targets)
+          user_targets.flat_map do |target|
+            Array(target.common_resolved_build_setting('ARCHS'))
+          end.compact.uniq.sort
+        end
+
+        # Checks if any of the targets for the {TargetDefinition} computed before
+        # by #compute_user_project_targets is recommended 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_recommends_frameworks(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
+      end
+    end
+  end
+end

lib/cocoapods/installer/file_references_installer.rb

@@ -8,9 +8,9 @@ module Pod
       #
       attr_reader :sandbox
 
-      # @return [Array<PodTarget>] The libraries of the installation.
+      # @return [Array<PodTarget>] The pod targets of the installation.
       #
-      attr_reader :libraries
+      attr_reader :pod_targets
 
       # @return [Project] The Pods project.
       #
@@ -19,12 +19,12 @@ module Pod
       # Initialize a new instance
       #
       # @param [Sandbox] sandbox @see sandbox
-      # @param [Array<PodTarget>] libraries @see libraries
-      # @param [Project] libraries @see libraries
+      # @param [Array<PodTarget>] pod_targets @see pod_targets
+      # @param [Project] pods_project @see pod_project
       #
-      def initialize(sandbox, libraries, pods_project)
+      def initialize(sandbox, pod_targets, pods_project)
         @sandbox = sandbox
-        @libraries = libraries
+        @pod_targets = pod_targets
         @pods_project = pods_project
       end
 
@@ -113,23 +113,23 @@ module Pod
       #
       def link_headers
         UI.message '- Linking headers' do
-          libraries.each do |library|
-            library.file_accessors.each do |file_accessor|
+          pod_targets.each do |pod_target|
+            pod_target.file_accessors.each do |file_accessor|
               framework_exp = /.framework\//
               headers_sandbox = Pathname.new(file_accessor.spec.root.name)
-              library.build_headers.add_search_path(headers_sandbox, library.platform)
-              sandbox.public_headers.add_search_path(headers_sandbox, library.platform)
+              pod_target.build_headers.add_search_path(headers_sandbox, pod_target.platform)
+              sandbox.public_headers.add_search_path(headers_sandbox, pod_target.platform)
 
               header_mappings(headers_sandbox, file_accessor, file_accessor.headers).each do |namespaced_path, files|
-                library.build_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, library.platform)
+                pod_target.build_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, pod_target.platform)
               end
 
               header_mappings(headers_sandbox, file_accessor, file_accessor.public_headers).each do |namespaced_path, files|
-                sandbox.public_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, library.platform)
+                sandbox.public_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, pod_target.platform)
               end
 
               vendored_frameworks_header_mappings(headers_sandbox, file_accessor).each do |namespaced_path, files|
-                sandbox.public_headers.add_files(namespaced_path, files, library.platform)
+                sandbox.public_headers.add_files(namespaced_path, files, pod_target.platform)
               end
             end
           end
@@ -146,7 +146,7 @@ module Pod
       #         specs platform combinations.
       #
       def file_accessors
-        @file_accessors ||= libraries.map(&:file_accessors).flatten.compact
+        @file_accessors ||= pod_targets.map(&:file_accessors).flatten.compact
       end
 
       # Adds file references to the list of the paths returned by the file

lib/cocoapods/installer/target_installer.rb

@@ -67,7 +67,7 @@ module Pod
       def custom_build_settings
         settings = {}
 
-        if target.archs
+        unless target.archs.empty?
           settings['ARCHS'] = target.archs
         end
 
@@ -184,12 +184,6 @@ module Pod
         sandbox.project
       end
 
-      # @return [TargetDefinition] the target definition of the library.
-      #
-      def target_definition
-        target.target_definition
-      end
-
       # @return [PBXGroup] the group where the file references to the support
       #         files should be stored.
       #

lib/cocoapods/installer/target_installer/aggregate_target_installer.rb

@@ -31,6 +31,12 @@ module Pod
 
       private
 
+      # @return [TargetDefinition] the target definition of the library.
+      #
+      def target_definition
+        target.target_definition
+      end
+
       # Ensure that vendored static frameworks and libraries are not linked
       # twice to the aggregate target, which shares the xcconfig of the user
       # target.
@@ -81,7 +87,7 @@ module Pod
       # @return [void]
       #
       def create_bridge_support_file
-        if target_definition.podfile.generate_bridge_support?
+        if target.podfile.generate_bridge_support?
           path = target.bridge_support_path
           headers = native_target.headers_build_phase.files.map { |bf| sandbox.root + bf.file_ref.path }
           generator = Generator::BridgeSupport.new(headers)
@@ -101,7 +107,7 @@ module Pod
         end
         resources_by_config = {}
         target.user_build_configurations.keys.each do |config|
-          file_accessors = library_targets.select { |t| t.include_in_build_config?(config) }.flat_map(&:file_accessors)
+          file_accessors = library_targets.select { |t| t.include_in_build_config?(target_definition, config) }.flat_map(&:file_accessors)
           resource_paths = file_accessors.flat_map { |accessor| accessor.resources.flat_map { |res| res.relative_path_from(project.path.dirname) } }
           resource_bundles = file_accessors.flat_map { |accessor| accessor.resource_bundles.keys.map { |name| "${BUILT_PRODUCTS_DIR}/#{name.shellescape}.bundle" } }
           resources_by_config[config] = (resource_paths + resource_bundles).uniq
@@ -138,11 +144,14 @@ module Pod
         path = target.embed_frameworks_script_path
         frameworks_by_config = {}
         target.user_build_configurations.keys.each do |config|
-          frameworks_by_config[config] = target.pod_targets.select do |pod_target|
-            pod_target.include_in_build_config?(config) && pod_target.should_build?
-          end.map(&:product_name)
+          relevant_pod_targets = target.pod_targets.select do |pod_target|
+            pod_target.include_in_build_config?(target_definition, config) && pod_target.should_build?
+          end
+          frameworks_by_config[config] = relevant_pod_targets.map do |pod_target|
+            "#{target_definition.label}/#{pod_target.product_name}"
+          end
         end
-        generator = Generator::EmbedFrameworksScript.new(target_definition, frameworks_by_config)
+        generator = Generator::EmbedFrameworksScript.new(frameworks_by_config)
         generator.save_as(path)
         add_file_to_support_group(path)
       end

lib/cocoapods/installer/target_installer/pod_target_installer.rb

@@ -130,7 +130,7 @@ module Pod
 
             bundle_target.build_configurations.each do |c|
               c.build_settings['PRODUCT_NAME'] = bundle_name
-              if target.requires_frameworks?
+              if target.requires_frameworks? && target.scoped?
                 c.build_settings['CONFIGURATION_BUILD_DIR'] = target.configuration_build_dir
               end
             end
@@ -234,7 +234,7 @@ module Pod
             flags << '-DOS_OBJECT_USE_OBJC=0'
           end
         end
-        if target_definition.inhibits_warnings_for_pod?(consumer.spec.root.name)
+        if target.inhibit_warnings?
           flags << '-w -Xanalyzer -analyzer-disable-all-checks'
         end
         flags * ' '

lib/cocoapods/target.rb

@@ -6,11 +6,6 @@ module Pod
   # This class is used to represent both the targets and their libraries.
   #
   class Target
-    # @return [TargetDefinition] the target definition of the Podfile that
-    #         generated this target.
-    #
-    attr_reader :target_definition
-
     # @return [Sandbox] The sandbox where the Pods should be installed.
     #
     attr_reader :sandbox
@@ -21,6 +16,12 @@ module Pod
     attr_accessor :host_requires_frameworks
     alias_method :host_requires_frameworks?, :host_requires_frameworks
 
+    # Initialize a new target
+    #
+    def initialize
+      @archs = []
+    end
+
     # @return [String] the name of the library.
     #
     def name
@@ -110,13 +111,7 @@ module Pod
     #
     attr_accessor :native_target
 
-    # @return [Platform] the platform for this library.
-    #
-    def platform
-      @platform ||= target_definition.platform
-    end
-
-    # @return [String] The value for the ARCHS build setting.
+    # @return [Array<String>] The value for the ARCHS build setting.
     #
     attr_accessor :archs
 
@@ -191,23 +186,6 @@ module Pod
       support_files_dir + "#{label}-dummy.m"
     end
 
-    # @return [String] The configuration build dir, if the target is integrated
-    #         as framework.
-    #
-    # @note   Namespace the pod target product with its target definition name.
-    #         Pod target products are named after their specs. The namespacing
-    #         cannot directly happen in the product name itself, because this
-    #         must be equal to the module name and this will be used in source
-    #         code, which should stay agnostic over the dependency manager.
-    #         We need namespacing at all because multiple targets can exist for
-    #         the same podspec and their products should not collide. This
-    #         happens when multiple user targets require the same pod, because
-    #         they could require different sets of subspecs.
-    #
-    def configuration_build_dir
-      "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/#{target_definition.label}"
-    end
-
     #-------------------------------------------------------------------------#
 
     private

lib/cocoapods/target/aggregate_target.rb

@@ -3,12 +3,17 @@ module Pod
   # of the single Pods. The client targets will then depend on this one.
   #
   class AggregateTarget < Target
+    # @return [TargetDefinition] the target definition of the Podfile that
+    #         generated this target.
+    attr_reader :target_definition
+
     # Initialize a new instance
     #
     # @param [TargetDefinition] target_definition @see target_definition
     # @param [Sandbox] sandbox @see sandbox
     #
     def initialize(target_definition, sandbox)
+      super()
       @target_definition = target_definition
       @sandbox = sandbox
       @pod_targets = []
@@ -30,6 +35,18 @@ module Pod
       c99ext_identifier(label)
     end
 
+    # @return [Platform] the platform for this target.
+    #
+    def platform
+      @platform ||= target_definition.platform
+    end
+
+    # @return [Podfile] The podfile which declares the dependency
+    #
+    def podfile
+      target_definition.podfile
+    end
+
     # @return [Pathname] the folder where the client is stored used for
     #         computing the relative paths. If integrating it should be the
     #         folder where the user project is stored, otherwise it should
@@ -94,7 +111,7 @@ module Pod
     #
     def pod_targets_for_build_configuration(build_configuration)
       pod_targets.select do |pod_target|
-        pod_target.include_in_build_config?(build_configuration)
+        pod_target.include_in_build_config?(target_definition, build_configuration)
       end
     end
 
@@ -182,6 +199,13 @@ module Pod
       "${SRCROOT}/#{relative_to_srcroot(embed_frameworks_script_path)}"
     end
 
+    # @return [String] The scoped configuration build dir, relevant if the
+    #         target is integrated as framework.
+    #
+    def scoped_configuration_build_dir
+      "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/#{target_definition.label}"
+    end
+
     private
 
     # @!group Private Helpers

lib/cocoapods/target/pod_target.rb

@@ -3,31 +3,87 @@ module Pod
   # A pod can have one or more activated spec/subspecs.
   #
   class PodTarget < Target
-    # @return [Specification] the spec for the target.
+    # @return [Array<Specification>] the spec and subspecs for the target.
     #
     attr_reader :specs
 
+    # @return [Array<PBXNativeTarget>] the target definitions of the Podfile
+    #         that generated this target.
+    #
+    attr_reader :target_definitions
+
     # @return [HeadersStore] the header directory for the target.
     #
     attr_reader :build_headers
 
-    # @param [Specification] spec @see spec
-    # @param [TargetDefinition] target_definition @see target_definition
+    # @return [Bool] whether the target needs to be scoped by target definition,
+    #         because the spec is used with different subspec sets across them.
+    #
+    # @note   For frameworks the target products of {PodTarget}s are named
+    #         after their specs. The namespacing cannot directly happen in
+    #         the product name itself, because this must be equal to the module
+    #         name and this will be used in source code, which should stay
+    #         agnostic over the dependency manager.
+    #         We need namespacing because multiple targets can exist for the
+    #         same podspec and their products should not collide. This
+    #         duplication is needed when multiple user targets have the same
+    #         dependency, but they require different sets of subspecs or they
+    #         are on different platforms.
+    #
+    attr_reader :scoped
+    alias_method :scoped?, :scoped
+
+    # @param [Array<Specification>] @spec #see spec
+    # @param [Array<TargetDefinition>] target_definitions @see target_definitions
     # @param [Sandbox] sandbox @see sandbox
+    # @param [Bool] scoped @see scoped
     #
-    def initialize(specs, target_definition, sandbox)
+    def initialize(specs, target_definitions, sandbox, scoped = false)
+      raise "Can't initialize a PodTarget without specs!" if specs.nil? || specs.empty?
+      raise "Can't initialize a PodTarget without TargetDefinition!" if target_definitions.nil? || target_definitions.empty?
+      super()
       @specs = specs
-      @target_definition = target_definition
+      @target_definitions = target_definitions
       @sandbox = sandbox
+      @scoped = scoped
       @build_headers  = Sandbox::HeadersStore.new(sandbox, 'Private')
       @file_accessors = []
       @resource_bundle_targets = []
     end
 
+    # @return [Array<PodTarget>] a scoped copy for each target definition.
+    #
+    def scoped
+      target_definitions.map do |target_definition|
+        PodTarget.new(specs, [target_definition], sandbox, true).tap do |target|
+          target.file_accessors = file_accessors
+          target.user_build_configurations = user_build_configurations
+          target.native_target = native_target
+          target.archs = archs
+        end
+      end
+    end
+
     # @return [String] the label for the target.
     #
     def label
-      "#{target_definition.label}-#{root_spec.name}"
+      if scoped?
+        "#{target_definitions.first.label}-#{root_spec.name}"
+      else
+        root_spec.name
+      end
+    end
+
+    # @return [Platform] the platform for this target.
+    #
+    def platform
+      @platform ||= target_definitions.first.platform
+    end
+
+    # @return [Podfile] The podfile which declares the dependency.
+    #
+    def podfile
+      target_definitions.first.podfile
     end
 
     # @return [String] The name to use for the source code module constructed
@@ -103,13 +159,16 @@ module Pod
     end
 
     # Checks if the target should be included in the build configuration with
-    # the given name.
+    # the given name of a given target definition.
+    #
+    # @param  [TargetDefinition] target_definition
+    #         The target definition to check.
     #
     # @param  [String] configuration_name
     #         The name of the build configuration.
     #
-    def include_in_build_config?(configuration_name)
-      whitelists = target_definition_dependencies.map do |dependency|
+    def include_in_build_config?(target_definition, configuration_name)
+      whitelists = target_definition_dependencies(target_definition).map do |dependency|
         target_definition.pod_whitelisted_for_configuration?(dependency.name, configuration_name)
       end.uniq
 
@@ -125,14 +184,51 @@ module Pod
       end
     end
 
+    # Checks if warnings should be inhibited for this pod.
+    #
+    # @return [Bool]
+    #
+    def inhibit_warnings?
+      whitelists = target_definitions.map do |target_definition|
+        target_definition.inhibits_warnings_for_pod?(root_spec.name)
+      end.uniq
+
+      if whitelists.empty?
+        return false
+      elsif whitelists.count == 1
+        whitelists.first
+      else
+        UI.warn "The pod `#{pod_name}` is linked to different targets " \
+          "(#{target_definitions.map(&:label)}), which contain different " \
+          'settings to inhibit warnings. CocoaPods does not currently ' \
+          'support different settings and will fall back to your preference ' \
+          'set in the root target definition.'
+        return podfile.root_target_definitions.first.inhibits_warnings_for_pod?(root_spec.name)
+      end
+    end
+
+    # @return [String] The configuration build dir, relevant if the target is
+    #         integrated as framework.
+    #
+    def configuration_build_dir
+      if scoped?
+        "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/#{target_definitions.first.label}"
+      else
+        '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)'
+      end
+    end
+
     private
 
+    # @param  [TargetDefinition] target_definition
+    #         The target definition to check.
+    #
     # @return [Array<Dependency>] The dependency of the target definition for
     #         this Pod. Return an empty array if the Pod is not a direct
     #         dependency of the target definition but the dependency of one or
     #         more Pods.
     #
-    def target_definition_dependencies
+    def target_definition_dependencies(target_definition)
       target_definition.dependencies.select do |dependency|
         Specification.root_name(dependency.name) == pod_name
       end

cocoapods-integration-specs @ 9793ea0f

-Subproject commit 0ce7a32ea385cf641ef76bd7f5a8166c554086d3
+Subproject commit 9793ea0fa86ceb9656ed768e58fa3d6db1407dd7

spec/fixtures/SampleProject/CLITool/main.swift

+//
+//  main.swift
+//  CLITool
+//
+//  Created by Marius Rackwitz on 3.6.15.
+//  Copyright (c) 2015 LJR Software Limited. All rights reserved.
+//
+
+import Foundation
+
+println("Hello, World!")
+

spec/fixtures/SampleProject/Sample Lib/Sample Lib.xcodeproj/project.pbxproj

@@ -114,7 +114,7 @@
 		51E94E06164472080035348C /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 0450;
+				LastUpgradeCheck = 0630;
 				ORGANIZATIONNAME = CocoaPods;
 			};
 			buildConfigurationList = 51E94E09164472080035348C /* Build configuration list for PBXProject "Sample Lib" */;
@@ -168,6 +168,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 6.0;
+				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 			};
 			name = Debug;
@@ -235,6 +236,7 @@
 				51E94E1F164472090035348C /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
 	};

spec/fixtures/SampleProject/SampleProject.xcodeproj/project.pbxproj

@@ -20,6 +20,7 @@
 /* End PBXAggregateTarget section */
 
 /* Begin PBXBuildFile section */
+		29FAC56D1B1F0502002187FA /* main.swift in Sources */ = {isa = PBXBuildFile; fileRef = 29FAC56C1B1F0502002187FA /* main.swift */; };
 		51075D4C1521D0C100E39B41 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A346497114F9BE9A0080D870 /* UIKit.framework */; };
 		51075D4D1521D0C100E39B41 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A346497314F9BE9A0080D870 /* Foundation.framework */; };
 		51075D4E1521D0C100E39B41 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A346497514F9BE9A0080D870 /* CoreGraphics.framework */; };
@@ -45,7 +46,21 @@
 		};
 /* End PBXContainerItemProxy section */
 
+/* Begin PBXCopyFilesBuildPhase section */
+		29FAC5681B1F0502002187FA /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = /usr/share/man/man1/;
+			dstSubfolderSpec = 0;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 1;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
 /* Begin PBXFileReference section */
+		29FAC56A1B1F0502002187FA /* CLITool */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = CLITool; sourceTree = BUILT_PRODUCTS_DIR; };
+		29FAC56C1B1F0502002187FA /* main.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = main.swift; sourceTree = "<group>"; };
 		51075D4A1521D0C100E39B41 /* TestRunner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = TestRunner.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		51075D511521D0C100E39B41 /* TestRunner-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "TestRunner-Info.plist"; sourceTree = "<group>"; };
 		51075D531521D0C100E39B41 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = "<group>"; };
@@ -67,6 +82,13 @@
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
+		29FAC5671B1F0502002187FA /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		51075D471521D0C100E39B41 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
@@ -91,6 +113,14 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		29FAC56B1B1F0502002187FA /* CLITool */ = {
+			isa = PBXGroup;
+			children = (
+				29FAC56C1B1F0502002187FA /* main.swift */,
+			);
+			path = CLITool;
+			sourceTree = "<group>";
+		};
 		51075D4F1521D0C100E39B41 /* TestRunner */ = {
 			isa = PBXGroup;
 			children = (
@@ -126,6 +156,7 @@
 				51E94E201644721F0035348C /* Sample Lib.xcodeproj */,
 				A346497714F9BE9A0080D870 /* SampleProject */,
 				51075D4F1521D0C100E39B41 /* TestRunner */,
+				29FAC56B1B1F0502002187FA /* CLITool */,
 				A346497014F9BE9A0080D870 /* Frameworks */,
 				A346496E14F9BE9A0080D870 /* Products */,
 			);
@@ -136,6 +167,7 @@
 			children = (
 				A346496D14F9BE9A0080D870 /* SampleProject.app */,
 				51075D4A1521D0C100E39B41 /* TestRunner.app */,
+				29FAC56A1B1F0502002187FA /* CLITool */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -174,6 +206,23 @@
 /* End PBXGroup section */
 
 /* Begin PBXNativeTarget section */
+		29FAC5691B1F0502002187FA /* CLITool */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 29FAC5731B1F0503002187FA /* Build configuration list for PBXNativeTarget "CLITool" */;
+			buildPhases = (
+				29FAC5661B1F0502002187FA /* Sources */,
+				29FAC5671B1F0502002187FA /* Frameworks */,
+				29FAC5681B1F0502002187FA /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = CLITool;
+			productName = CLITool;
+			productReference = 29FAC56A1B1F0502002187FA /* CLITool */;
+			productType = "com.apple.product-type.tool";
+		};
 		51075D491521D0C100E39B41 /* TestRunner */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 51075D5B1521D0C100E39B41 /* Build configuration list for PBXNativeTarget "TestRunner" */;
@@ -214,8 +263,13 @@
 		A346496414F9BE990080D870 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 0430;
+				LastUpgradeCheck = 0630;
 				ORGANIZATIONNAME = "LJR Software Limited";
+				TargetAttributes = {
+					29FAC5691B1F0502002187FA = {
+						CreatedOnToolsVersion = 6.3.2;
+					};
+				};
 			};
 			buildConfigurationList = A346496714F9BE990080D870 /* Build configuration list for PBXProject "SampleProject" */;
 			compatibilityVersion = "Xcode 3.2";
@@ -238,6 +292,7 @@
 				A346496C14F9BE9A0080D870 /* SampleProject */,
 				51075D491521D0C100E39B41 /* TestRunner */,
 				51D6A8AB16C445B800E174E1 /* AggregateTarget */,
+				29FAC5691B1F0502002187FA /* CLITool */,
 			);
 		};
 /* End PBXProject section */
@@ -272,6 +327,14 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
+		29FAC5661B1F0502002187FA /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				29FAC56D1B1F0502002187FA /* main.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
 		51075D461521D0C100E39B41 /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
@@ -312,6 +375,89 @@
 /* End PBXVariantGroup section */
 
 /* Begin XCBuildConfiguration section */
+		29FAC56E1B1F0502002187FA /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				MACOSX_DEPLOYMENT_TARGET = 10.10;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		29FAC56F1B1F0502002187FA /* Test */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				MACOSX_DEPLOYMENT_TARGET = 10.10;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+			};
+			name = Test;
+		};
+		29FAC5701B1F0502002187FA /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				MACOSX_DEPLOYMENT_TARGET = 10.10;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		29FAC5711B1F0502002187FA /* App Store */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				MACOSX_DEPLOYMENT_TARGET = 10.10;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+			};
+			name = "App Store";
+		};
 		51075D5C1521D0C100E39B41 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
@@ -344,12 +490,20 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"DEBUG=1",
@@ -357,8 +511,11 @@
 				);
 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
 				SDKROOT = iphoneos;
@@ -394,14 +551,25 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
 				OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
@@ -467,12 +635,20 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"DEBUG=1",
@@ -480,10 +656,14 @@
 				);
 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 			};
 			name = Debug;
@@ -492,14 +672,25 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ARCHS = "$(ARCHS_STANDARD_32_BIT)";
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
 				OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1";
@@ -533,6 +724,16 @@
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
+		29FAC5731B1F0503002187FA /* Build configuration list for PBXNativeTarget "CLITool" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				29FAC56E1B1F0502002187FA /* Debug */,
+				29FAC56F1B1F0502002187FA /* Test */,
+				29FAC5701B1F0502002187FA /* Release */,
+				29FAC5711B1F0502002187FA /* App Store */,
+			);
+			defaultConfigurationIsVisible = 0;
+		};
 		51075D5B1521D0C100E39B41 /* Build configuration list for PBXNativeTarget "TestRunner" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
@@ -553,6 +754,7 @@
 				51D6A8AF16C445B800E174E1 /* App Store */,
 			);
 			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
 		};
 		A346496714F9BE990080D870 /* Build configuration list for PBXProject "SampleProject" */ = {
 			isa = XCConfigurationList;

spec/spec_helper.rb

@@ -109,36 +109,31 @@ def fixture_spec(name)
   Pod::Specification.from_file(file)
 end
 
-def fixture_file_accessor(name, platform = :ios)
-  file = SpecHelper::Fixture.fixture(name)
-  spec = Pod::Specification.from_file(file)
-  path_list = Pod::Sandbox::PathList.new(file.dirname)
+def fixture_file_accessor(spec_or_name, platform = Pod::Platform.ios)
+  spec = spec_or_name.is_a?(Pod::Specification) ? spec_or_name : fixture_spec(spec_or_name)
+  path_list = Pod::Sandbox::PathList.new(spec.defined_in_file.dirname)
   Pod::Sandbox::FileAccessor.new(path_list, spec.consumer(platform))
 end
 
-def fixture_target_definition(podfile = nil, &block)
-  podfile ||= Pod::Podfile.new(&block)
-  Pod::Podfile::TargetDefinition.new('Pods', podfile)
+def fixture_target_definition(name = 'Pods', platform = Pod::Platform.ios)
+  Pod::Podfile::TargetDefinition.new(name, Pod::Podfile.new, 'name' => name, 'platform' => platform)
 end
 
-def fixture_pod_target(spec_or_name, platform = :ios, target_definition = nil)
+def fixture_pod_target(spec_or_name, target_definition = nil)
   spec = spec_or_name.is_a?(Pod::Specification) ? spec_or_name : fixture_spec(spec_or_name)
   target_definition ||= fixture_target_definition
   target_definition.store_pod(spec.name)
-  Pod::PodTarget.new([spec], target_definition, config.sandbox).tap do |pod_target|
-    pod_target.stubs(:platform).returns(platform)
-    pod_target.file_accessors << fixture_file_accessor(spec.defined_in_file, platform)
-    consumer = spec.consumer(platform)
+  Pod::PodTarget.new([spec], [target_definition], config.sandbox).tap do |pod_target|
+    pod_target.file_accessors << fixture_file_accessor(spec, pod_target.platform)
+    consumer = spec.consumer(pod_target.platform)
     pod_target.spec_consumers << consumer
   end
 end
 
-def fixture_aggregate_target(pod_targets = [], platform = :ios, target_definition = nil)
-  target_definition ||= pod_targets.map(&:target_definition).first || fixture_target_definition
+def fixture_aggregate_target(pod_targets = [], target_definition = nil)
+  target_definition ||= pod_targets.flat_map(&:target_definitions).first || fixture_target_definition
   target = Pod::AggregateTarget.new(target_definition, config.sandbox)
   target.client_root = config.sandbox.root.dirname
-  version ||= (platform == :ios ? '4.3' : '10.6')
-  target.stubs(:platform).returns(Pod::Platform.new(platform, version))
   target.pod_targets = pod_targets
   target
 end

spec/spec_helper/fixture.rb

@@ -9,6 +9,10 @@ module SpecHelper
     fixture_copy_path + "#{fixture_name}.xcodeproj"
   end
 
+  def self.test_repo_url
+    'https://github.com/CocoaPods/test_repo.git'
+  end
+
   module Fixture
     ROOT = ::ROOT + 'spec/fixtures'
 

spec/unit/config_spec.rb

@@ -184,6 +184,14 @@ module Pod
         @config.should.lock_pod_source
       end
 
+      it 'integrates a user target' do
+        @config.should.integrate_targets
+      end
+
+      it 'de-duplicates targets' do
+        @config.should.deduplicate_targets
+      end
+
       it 'returns the cache root' do
         @config.cache_root.should == Pathname.new(File.join(ENV['HOME'], 'Library/Caches/CocoaPods'))
       end

spec/unit/generator/embed_frameworks_script_spec.rb

@@ -3,15 +3,14 @@ require File.expand_path('../../../spec_helper', __FILE__)
 module Pod
   describe Generator::EmbedFrameworksScript do
     it 'returns the embed frameworks script' do
-      target_definition = Podfile::TargetDefinition.new(:default, nil)
       frameworks = {
-        'Debug'   => %w(Loopback.framework Reveal.framework),
+        'Debug'   => %w(Pods/Loopback.framework Reveal.framework),
         'Release' => %w(CrashlyticsFramework.framework),
       }
-      generator = Pod::Generator::EmbedFrameworksScript.new(target_definition, frameworks)
+      generator = Pod::Generator::EmbedFrameworksScript.new(frameworks)
       generator.send(:script).should.include <<-eos.strip_heredoc
         if [[ "$CONFIGURATION" == "Debug" ]]; then
-          install_framework 'Loopback.framework'
+          install_framework 'Pods/Loopback.framework'
           install_framework 'Reveal.framework'
         fi
       eos

spec/unit/generator/module_map_spec.rb

@@ -5,7 +5,7 @@ module Pod
     before do
       spec = fixture_spec('banana-lib/BananaLib.podspec')
       target_definition = Podfile::TargetDefinition.new(:default, nil)
-      @pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+      @pod_target = PodTarget.new([spec], [target_definition], config.sandbox)
       @gen = Generator::ModuleMap.new(@pod_target)
     end
 
@@ -14,7 +14,7 @@ module Pod
       @gen.save_as(path)
       path.read.should == <<-EOS.strip_heredoc
         framework module BananaLib {
-          umbrella header "Pods-default-BananaLib-umbrella.h"
+          umbrella header "BananaLib-umbrella.h"
 
           export *
           module * { export * }
@@ -26,7 +26,7 @@ module Pod
       @gen.stubs(:private_headers).returns(['Private.h'])
       @gen.generate.should == <<-EOS.strip_heredoc
         framework module BananaLib {
-          umbrella header "Pods-default-BananaLib-umbrella.h"
+          umbrella header "BananaLib-umbrella.h"
 
           export *
           module * { export * }

spec/unit/generator/xcconfig/aggregate_xcconfig_spec.rb

@@ -8,12 +8,16 @@ module Pod
           fixture_spec('banana-lib/BananaLib.podspec')
         end
 
+        def pod_target(spec)
+          fixture_pod_target(spec)
+        end
+
         before do
           @spec = spec
-          @pod_target = fixture_pod_target(@spec)
+          @pod_target = pod_target(@spec)
           @consumer = @pod_target.spec_consumers.last
           @target = fixture_aggregate_target([@pod_target])
-          @target.target_definition.should == @pod_target.target_definition
+          @target.target_definition.should == @pod_target.target_definitions.first
           @target.target_definition.whitelist_pod_for_configuration(@spec.name, 'Release')
           @podfile = @target.target_definition.podfile
           @generator = AggregateXCConfig.new(@target, 'Release')
@@ -103,8 +107,20 @@ module Pod
             @xcconfig.to_hash['OTHER_CFLAGS'].should == expected
           end
 
-          it 'links the pod targets with the aggregate target' do
-            @xcconfig.to_hash['OTHER_LDFLAGS'].should.include '-l"Pods-BananaLib"'
+          describe 'with a scoped pod target' do
+            def pod_target(spec)
+              fixture_pod_target(spec).scoped.first
+            end
+
+            it 'links the pod targets with the aggregate target' do
+              @xcconfig.to_hash['OTHER_LDFLAGS'].should.include '-l"Pods-BananaLib"'
+            end
+          end
+
+          describe 'with an unscoped pod target' do
+            it 'links the pod targets with the aggregate target' do
+              @xcconfig.to_hash['OTHER_LDFLAGS'].should.include '-l"BananaLib"'
+            end
           end
 
           it 'does not links the pod targets with the aggregate target for non-whitelisted configuration' do
@@ -139,13 +155,30 @@ module Pod
             @xcconfig.to_hash['PODS_FRAMEWORK_BUILD_PATH'].should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/Pods'
           end
 
-          it 'adds the framework build path to the xcconfig, with quotes, as framework search paths' do
-            @xcconfig.to_hash['FRAMEWORK_SEARCH_PATHS'].should == '$(inherited) "$PODS_FRAMEWORK_BUILD_PATH"'
+          describe 'with a scoped pod target' do
+            def pod_target(spec)
+              fixture_pod_target(spec).scoped.first
+            end
+
+            it 'adds the framework build path to the xcconfig, with quotes, as framework search paths' do
+              @xcconfig.to_hash['FRAMEWORK_SEARCH_PATHS'].should == '$(inherited) "$PODS_FRAMEWORK_BUILD_PATH"'
+            end
+
+            it 'adds the framework header paths to the xcconfig, with quotes, as local headers' do
+              expected = '$(inherited) -iquote "$PODS_FRAMEWORK_BUILD_PATH/OrangeFramework.framework/Headers"'
+              @xcconfig.to_hash['OTHER_CFLAGS'].should == expected
+            end
           end
 
-          it 'adds the framework header paths to the xcconfig, with quotes, as local headers' do
-            expected = '$(inherited) -iquote "$PODS_FRAMEWORK_BUILD_PATH/OrangeFramework.framework/Headers"'
-            @xcconfig.to_hash['OTHER_CFLAGS'].should == expected
+          describe 'with an unscoped pod target' do
+            it 'adds the framework build path to the xcconfig, with quotes, as framework search paths' do
+              @xcconfig.to_hash['FRAMEWORK_SEARCH_PATHS'].should.be.nil
+            end
+
+            it 'adds the framework header paths to the xcconfig, with quotes, as local headers' do
+              expected = '$(inherited) -iquote "$CONFIGURATION_BUILD_DIR/OrangeFramework.framework/Headers"'
+              @xcconfig.to_hash['OTHER_CFLAGS'].should == expected
+            end
           end
 
           it 'links the pod targets with the aggregate target' do
@@ -195,7 +228,7 @@ module Pod
               @consumer_b.stubs(:user_target_xcconfig).returns('ENABLE_HEADER_DEPENDENCIES' => 'NO')
               @xcconfig = @generator.generate
               UI.warnings.should.include 'Can\'t merge user_target_xcconfig for pod targets: ' \
-                '["Pods-BananaLib", "Pods-OrangeFramework"]. Boolean build setting '\
+                '["BananaLib", "OrangeFramework"]. Boolean build setting '\
                 'ENABLE_HEADER_DEPENDENCIES has different values.'
             end
           end
@@ -229,7 +262,7 @@ module Pod
               @consumer_b.stubs(:user_target_xcconfig).returns('STRIP_STYLE' => 'all')
               @xcconfig = @generator.generate
               UI.warnings.should.include 'Can\'t merge user_target_xcconfig for pod targets: ' \
-                '["Pods-BananaLib", "Pods-OrangeFramework"]. Singular build setting '\
+                '["BananaLib", "OrangeFramework"]. Singular build setting '\
                 'STRIP_STYLE has different values.'
             end
           end

spec/unit/generator/xcconfig/private_pod_xcconfig_spec.rb

@@ -7,14 +7,11 @@ module Pod
         describe 'in general' do
           before do
             @spec = fixture_spec('banana-lib/BananaLib.podspec')
-            @consumer = @spec.consumer(:ios)
-            target_definition = Podfile::TargetDefinition.new('Pods', nil)
-            @pod_target = PodTarget.new([@spec], target_definition, config.sandbox)
-            @pod_target.stubs(:platform).returns(:ios)
+            @pod_target = fixture_pod_target(@spec)
+            @consumer = @pod_target.spec_consumers.first
+            @podfile = @pod_target.podfile
             public_xcconfig = Xcodeproj::Config.new('OTHER_LDFLAGS' => '-framework SystemConfiguration')
             @generator = PrivatePodXCConfig.new(@pod_target, public_xcconfig)
-            @podfile = Podfile.new
-            @pod_target.target_definition.stubs(:podfile).returns(@podfile)
             @xcconfig = @generator.generate
           end
 

spec/unit/generator/xcconfig/public_pod_xcconfig_spec.rb

@@ -6,23 +6,16 @@ module Pod
       describe PublicPodXCConfig do
         before do
           @spec = fixture_spec('banana-lib/BananaLib.podspec')
-          @target_definition = Podfile::TargetDefinition.new('Pods', nil)
-          @pod_target = PodTarget.new([@spec], @target_definition, config.sandbox)
-          @pod_target.stubs(:platform).returns(:ios)
+          @pod_target = fixture_pod_target(@spec)
           @generator = PublicPodXCConfig.new(@pod_target)
 
-          @podfile = Podfile.new
           @spec.xcconfig = { 'OTHER_LDFLAGS' => '-no_compact_unwind' }
           @spec.frameworks = ['QuartzCore']
           @spec.weak_frameworks = ['iAd']
           @spec.libraries = ['xml2']
-          file_accessors = [Sandbox::FileAccessor.new(fixture('banana-lib'), @spec.consumer(:ios))]
           # vendored_framework_paths = [config.sandbox.root + 'BananaLib/BananaLib.framework']
           # Sandbox::FileAccessor.any_instance.stubs(:vendored_frameworks).returns(vendored_framework_paths)
 
-          @pod_target.target_definition.stubs(:podfile).returns(@podfile)
-          @pod_target.stubs(:file_accessors).returns(file_accessors)
-
           @xcconfig = @generator.generate
         end
 

spec/unit/generator/xcconfig/xcconfig_helper_spec.rb

@@ -13,17 +13,15 @@ module Pod
         describe '::default_ld_flags' do
           it 'returns the default linker flags' do
             podfile = stub(:set_arc_compatibility_flag? => false)
-            target_definition = stub(:podfile => podfile)
-            target = stub(:target_definition => target_definition)
+            target = stub(:podfile => podfile)
             result = @sut.default_ld_flags(target)
             result.should == '-ObjC'
           end
 
           it 'includes the ARC compatibility flag if required by the Podfile' do
             podfile = stub(:set_arc_compatibility_flag? => true)
-            target_definition = stub(:podfile => podfile)
             spec_consumer = stub(:requires_arc? => true)
-            target = stub(:target_definition => target_definition,  :spec_consumers => [spec_consumer])
+            target = stub(:podfile => podfile, :spec_consumers => [spec_consumer])
             result = @sut.default_ld_flags(target)
             result.should == '-ObjC -fobjc-arc'
           end

spec/unit/installer/analyzer/target_inspector_spec.rb

+require File.expand_path('../../../../spec_helper', __FILE__)
+
+module Pod
+  describe TargetInspector = Installer::Analyzer::TargetInspector do
+    before do
+      SpecHelper.create_sample_app_copy_from_fixture('SampleProject')
+    end
+
+    describe '#compute_project_path' do
+      it 'uses the path specified in the target definition while computing the path of the user project' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.user_project_path = 'SampleProject/SampleProject'
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        path = target_inspector.send(:compute_project_path)
+        path.to_s.should.include 'SampleProject/SampleProject.xcodeproj'
+      end
+
+      it 'raises if the user project of the target definition does not exists while computing the path of the user project' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.user_project_path = 'Test'
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_project_path) }.should.raise Informative
+        e.message.should.match /Unable to find/
+      end
+
+      it 'looks if there is only one project if not specified in the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        config.installation_root = config.installation_root + 'SampleProject'
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        path = target_inspector.send(:compute_project_path)
+        path.to_s.should.include 'SampleProject/SampleProject.xcodeproj'
+      end
+
+      it 'raise if there is no project and none specified in the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_project_path) }.should.raise Informative
+        e.message.should.match /Could not.*select.*project/
+      end
+
+      it 'finds project even when path contains special chars' do
+        SpecHelper.create_sample_app_copy_from_fixture('Project[With]Special{chars}in*path?')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        config.installation_root = config.installation_root + 'Project[With]Special{chars}in*path?'
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        path = target_inspector.send(:compute_project_path)
+        path.to_s.should.include 'Project[With]Special{chars}in*path?/Project[With]Special{chars}in*path?.xcodeproj'
+      end
+    end
+
+    #--------------------------------------#
+
+    describe '#compute_targets' do
+      it 'returns the targets specified in the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.link_with = ['UserTarget']
+        user_project = Xcodeproj::Project.new('path')
+        user_project.new_target(:application, 'FirstTarget', :ios)
+        user_project.new_target(:application, 'UserTarget', :ios)
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        targets = target_inspector.send(:compute_targets, user_project)
+        targets.map(&:name).should == ['UserTarget']
+      end
+
+      it 'raises if it is unable to find the targets specified by the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.link_with = %w(UserTarget AnotherUserTarget)
+        user_project = Xcodeproj::Project.new('path')
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_targets, user_project) }.should.raise Informative
+        e.message.should.match /Unable to find the targets named `UserTarget` and `AnotherUserTarget`/
+      end
+
+      it 'returns the target with the same name of the target definition' do
+        target_definition = Podfile::TargetDefinition.new('UserTarget', nil)
+        user_project = Xcodeproj::Project.new('path')
+        user_project.new_target(:application, 'FirstTarget', :ios)
+        user_project.new_target(:application, 'UserTarget', :ios)
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        targets = target_inspector.send(:compute_targets, user_project)
+        targets.map(&:name).should == ['UserTarget']
+      end
+
+      it 'raises if the name of the target definition does not match any file' do
+        target_definition = Podfile::TargetDefinition.new('UserTarget', nil)
+        user_project = Xcodeproj::Project.new('path')
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_targets, user_project) }.should.raise Informative
+        e.message.should.match /Unable to find a target named/
+      end
+
+      it 'returns the first target of the project if the target definition is named default' do
+        target_definition = Podfile::TargetDefinition.new('Pods', nil)
+        target_definition.link_with_first_target = true
+        user_project = Xcodeproj::Project.new('path')
+        user_project.new_target(:application, 'FirstTarget', :ios)
+        user_project.new_target(:application, 'UserTarget', :ios)
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        targets = target_inspector.send(:compute_targets, user_project)
+        targets.map(&:name).should == ['FirstTarget']
+      end
+
+      it 'raises if the default target definition cannot be linked because there are no user targets' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        user_project = Xcodeproj::Project.new('path')
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_targets, user_project) }.should.raise Informative
+        e.message.should.match /Unable to find a target/
+      end
+    end
+
+    #--------------------------------------#
+
+    describe '#compute_build_configurations' do
+      it 'returns the user build configurations of the user targets' do
+        user_project = Xcodeproj::Project.new('path')
+        target = user_project.new_target(:application, 'Target', :ios)
+        configuration = user_project.new(Xcodeproj::Project::Object::XCBuildConfiguration)
+        configuration.name = 'AppStore'
+        target.build_configuration_list.build_configurations << configuration
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        user_targets = [target]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        configurations = target_inspector.send(:compute_build_configurations, user_targets)
+        configurations.should == {
+          'Debug'    => :debug,
+          'Release'  => :release,
+          'AppStore' => :release,
+        }
+      end
+
+      it 'returns the user build configurations specified in the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.build_configurations = { 'AppStore' => :release }
+        user_targets = []
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        configurations = target_inspector.send(:compute_build_configurations, user_targets)
+        configurations.should == { 'AppStore' => :release }
+      end
+    end
+
+    #--------------------------------------#
+
+    describe '#compute_archs' do
+      it 'handles a single ARCH defined in a single user target' do
+        user_project = Xcodeproj::Project.new('path')
+        target = user_project.new_target(:application, 'Target', :ios)
+        target.build_configuration_list.set_setting('ARCHS', 'armv7')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.set_platform(:ios, '4.0')
+        user_targets = [target]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        archs = target_inspector.send(:compute_archs, user_targets)
+        archs.should == %w(armv7)
+      end
+
+      it 'handles a single ARCH defined in multiple user targets' do
+        user_project = Xcodeproj::Project.new('path')
+        targeta = user_project.new_target(:application, 'Target', :ios)
+        targeta.build_configuration_list.set_setting('ARCHS', 'armv7')
+        targetb = user_project.new_target(:application, 'Target', :ios)
+        targetb.build_configuration_list.set_setting('ARCHS', 'armv7')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.set_platform(:ios, '4.0')
+        user_targets = [targeta, targetb]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        archs = target_inspector.send(:compute_archs, user_targets)
+        archs.should == %w(armv7)
+      end
+
+      it 'handles an Array of ARCHs defined in a single user target' do
+        user_project = Xcodeproj::Project.new('path')
+        target = user_project.new_target(:application, 'Target', :ios)
+        target.build_configuration_list.set_setting('ARCHS', %w(armv7 i386))
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.set_platform(:ios, '4.0')
+        user_targets = [target]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        archs = target_inspector.send(:compute_archs, user_targets)
+        archs.uniq.sort.should == %w(armv7 i386)
+      end
+
+      it 'handles an Array of ARCHs defined multiple user targets' do
+        user_project = Xcodeproj::Project.new('path')
+        target_a = user_project.new_target(:application, 'Target', :ios)
+        target_a.build_configuration_list.set_setting('ARCHS', %w(armv7 armv7s))
+        target_b = user_project.new_target(:application, 'Target', :ios)
+        target_b.build_configuration_list.set_setting('ARCHS', %w(armv7 i386))
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.set_platform(:ios, '4.0')
+        user_targets = [target_a, target_b]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        archs = target_inspector.send(:compute_archs, user_targets)
+        archs.uniq.sort.should == %w(armv7 armv7s i386)
+      end
+    end
+
+    #--------------------------------------#
+
+    describe '#compute_platform' do
+      it 'returns the platform specified in the target definition' do
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        target_definition.set_platform(:ios, '4.0')
+        user_targets = []
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        platforms = target_inspector.send(:compute_platform, user_targets)
+        platforms.should == Platform.new(:ios, '4.0')
+      end
+
+      it 'infers the platform from the user targets' do
+        user_project = Xcodeproj::Project.new('path')
+        target = user_project.new_target(:application, 'Target', :ios)
+        target.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
+        target.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        user_targets = [target]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        platforms = target_inspector.send(:compute_platform, user_targets)
+        platforms.should == Platform.new(:ios, '4.0')
+      end
+
+      it 'uses the lowest deployment target of the user targets if inferring the platform' do
+        user_project = Xcodeproj::Project.new('path')
+        target1 = user_project.new_target(:application, 'Target', :ios)
+        target1.build_configuration_list.build_configurations.first
+        target1.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
+        target1.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
+
+        target2 = user_project.new_target(:application, 'Target', :ios)
+        target2.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
+        target2.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '6.0')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        user_targets = [target1, target2]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        platforms = target_inspector.send(:compute_platform, user_targets)
+        platforms.should == Platform.new(:ios, '4.0')
+      end
+
+      it 'raises if the user targets have a different platform' do
+        user_project = Xcodeproj::Project.new('path')
+        target1 = user_project.new_target(:application, 'Target', :ios)
+        target1.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
+        target1.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
+
+        target2 = user_project.new_target(:application, 'Target', :ios)
+        target2.build_configuration_list.set_setting('SDKROOT', 'macosx')
+        target2.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '10.6')
+
+        target_definition = Podfile::TargetDefinition.new(:default, nil)
+        user_targets = [target1, target2]
+
+        target_inspector = TargetInspector.new(target_definition, config.installation_root)
+        e = lambda { target_inspector.send(:compute_platform, user_targets) }.should.raise Informative
+        e.message.should.match /Targets with different platforms/
+      end
+    end
+  end
+end

spec/unit/installer/analyzer_spec.rb

 require File.expand_path('../../../spec_helper', __FILE__)
 
-#-----------------------------------------------------------------------------#
-
 module Pod
   describe Installer::Analyzer do
     describe 'Analysis' do
@@ -13,6 +11,11 @@ module Pod
           pod 'AFNetworking',                '1.0.1'
           pod 'SVPullToRefresh',             '0.4'
           pod 'libextobjc/EXTKeyPathCoding', '0.2.3'
+
+          target 'TestRunner' do
+            pod 'libextobjc/EXTKeyPathCoding', '0.2.3'
+            pod 'libextobjc/EXTSynthesize',    '0.2.3'
+          end
         end
 
         hash = {}
@@ -44,7 +47,7 @@ module Pod
 
       it 'computes the state of the Podfile respect to the Lockfile' do
         state = @analyzer.analyze.podfile_state
-        state.added.should     == %w(AFNetworking libextobjc/EXTKeyPathCoding)
+        state.added.should     == %w(AFNetworking libextobjc/EXTKeyPathCoding libextobjc/EXTSynthesize)
         state.changed.should   == %w()
         state.unchanged.should == %w(JSONKit SVPullToRefresh)
         state.deleted.should   == %w(NUI)
@@ -87,16 +90,18 @@ module Pod
 
       #--------------------------------------#
 
-      it 'generates the libraries which represent the target definitions' do
+      it 'generates the model to represent the target definitions' do
         target = @analyzer.analyze.targets.first
         target.pod_targets.map(&:name).sort.should == [
-          'Pods-JSONKit',
-          'Pods-AFNetworking',
-          'Pods-SVPullToRefresh',
+          'JSONKit',
+          'AFNetworking',
+          'SVPullToRefresh',
           'Pods-libextobjc',
         ].sort
         target.support_files_dir.should == config.sandbox.target_support_files_dir('Pods')
 
+        target.pod_targets.map(&:archs).uniq.should == [[]]
+
         target.user_project_path.to_s.should.include 'SampleProject/SampleProject'
         target.client_root.to_s.should.include 'SampleProject'
         target.user_target_uuids.should == ['A346496C14F9BE9A0080D870']
@@ -111,6 +116,69 @@ module Pod
         target.platform.to_s.should == 'iOS 6.0'
       end
 
+      describe 'deduplication' do
+        before do
+          repos = [fixture('spec-repos/test_repo'), fixture('spec-repos/master')]
+          aggregate = Pod::Source::Aggregate.new(repos)
+          Pod::SourcesManager.stubs(:aggregate).returns(aggregate)
+          aggregate.sources.first.stubs(:url).returns(SpecHelper.test_repo_url)
+        end
+
+        it 'deduplicate targets if possible' do
+          podfile = Pod::Podfile.new do
+            source SpecHelper.test_repo_url
+            platform :ios, '6.0'
+            xcodeproj 'SampleProject/SampleProject'
+            pod 'BananaLib'
+            pod 'monkey'
+
+            target 'TestRunner' do
+              pod 'BananaLib'
+              pod 'monkey'
+            end
+          end
+          analyzer = Pod::Installer::Analyzer.new(config.sandbox, podfile)
+          analyzer.analyze
+
+          analyzer.analyze.targets.flat_map { |at| at.pod_targets.map { |pt| "#{at.name}/#{pt.name}" } }.sort.should == %w(
+            Pods/BananaLib
+            Pods/monkey
+            Pods-TestRunner/BananaLib
+            Pods-TestRunner/monkey
+          ).sort
+        end
+
+        it "doesn't deduplicate targets, where transitive dependencies can't be deduplicated" do
+          podfile = Pod::Podfile.new do
+            source SpecHelper.test_repo_url
+            platform :ios, '6.0'
+            xcodeproj 'SampleProject/SampleProject'
+            pod 'BananaLib'
+            pod 'monkey'
+
+            target 'TestRunner' do
+              pod 'BananaLib'
+              pod 'monkey'
+            end
+
+            target 'CLITool' do
+              platform :osx, '10.10'
+              pod 'monkey'
+            end
+          end
+          analyzer = Pod::Installer::Analyzer.new(config.sandbox, podfile)
+          analyzer.analyze
+
+          analyzer.analyze.targets.flat_map { |at| at.pod_targets.map { |pt| "#{at.name}/#{pt.name}" } }.sort.should == %w(
+            Pods/Pods-BananaLib
+            Pods/Pods-monkey
+            Pods-TestRunner/Pods-TestRunner-BananaLib
+            Pods-TestRunner/Pods-monkey
+            Pods-CLITool/Pods-CLITool-monkey
+          ).sort
+        end
+      end
+
       it 'generates the integration library appropriately if the installation will not integrate' do
         config.integrate_targets = false
         target = @analyzer.analyze.targets.first
@@ -256,6 +324,7 @@ module Pod
           'JSONKit (1.5pre)',
           'SVPullToRefresh (0.4)',
           'libextobjc/EXTKeyPathCoding (0.2.3)',
+          'libextobjc/EXTSynthesize (0.2.3)',
         ]
       end
 
@@ -275,12 +344,19 @@ module Pod
       end
 
       it 'adds the specifications to the correspondent libraries' do
-        @analyzer.analyze.targets.first.pod_targets.map(&:specs).flatten.map(&:to_s).should == [
+        @analyzer.analyze.targets[0].pod_targets.map(&:specs).flatten.map(&:to_s).should == [
           'AFNetworking (1.0.1)',
           'JSONKit (1.5pre)',
           'SVPullToRefresh (0.4)',
           'libextobjc/EXTKeyPathCoding (0.2.3)',
         ]
+        @analyzer.analyze.targets[1].pod_targets.map(&:specs).flatten.map(&:to_s).should == [
+          'AFNetworking (1.0.1)',
+          'JSONKit (1.5pre)',
+          'SVPullToRefresh (0.4)',
+          'libextobjc/EXTKeyPathCoding (0.2.3)',
+          'libextobjc/EXTSynthesize (0.2.3)',
+        ]
       end
 
       #--------------------------------------#
@@ -318,271 +394,6 @@ module Pod
       #-------------------------------------------------------------------------#
 
       describe 'Private helpers' do
-        describe '#compute_user_project_targets' do
-          it 'uses the path specified in the target definition while computing the path of the user project' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.user_project_path = 'SampleProject/SampleProject'
-
-            path = @analyzer.send(:compute_user_project_path, target_definition)
-            path.to_s.should.include 'SampleProject/SampleProject.xcodeproj'
-          end
-
-          it 'raises if the user project of the target definition does not exists while computing the path of the user project' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.user_project_path = 'Test'
-
-            e = lambda { @analyzer.send(:compute_user_project_path, target_definition) }.should.raise Informative
-            e.message.should.match /Unable to find/
-          end
-
-          it 'looks if there is only one project if not specified in the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            config.installation_root = config.installation_root + 'SampleProject'
-
-            path = @analyzer.send(:compute_user_project_path, target_definition)
-            path.to_s.should.include 'SampleProject/SampleProject.xcodeproj'
-          end
-
-          it 'raise if there is no project and none specified in the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-
-            e = lambda { @analyzer.send(:compute_user_project_path, target_definition) }.should.raise Informative
-            e.message.should.match /Could not.*select.*project/
-          end
-
-          it 'finds project even when path contains special chars' do
-            SpecHelper.create_sample_app_copy_from_fixture('Project[With]Special{chars}in*path?')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            config.installation_root = config.installation_root + 'Project[With]Special{chars}in*path?'
-
-            path = @analyzer.send(:compute_user_project_path, target_definition)
-            path.to_s.should.include 'Project[With]Special{chars}in*path?/Project[With]Special{chars}in*path?.xcodeproj'
-          end
-
-          it 'does not take aggregate targets into consideration' do
-            aggregate_class = Xcodeproj::Project::Object::PBXAggregateTarget
-            sample_project_path = SpecHelper.create_sample_app_copy_from_fixture('SampleProject')
-            sample_project = Xcodeproj::Project.open(sample_project_path)
-            sample_project.targets.map(&:class).should.include(aggregate_class)
-
-            native_targets = @analyzer.send(:native_targets, sample_project).map(&:class)
-            native_targets.should.not.include(aggregate_class)
-          end
-        end
-
-        #--------------------------------------#
-
-        describe '#compute_user_project_targets' do
-          it 'returns the targets specified in the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.link_with = ['UserTarget']
-            user_project = Xcodeproj::Project.new('path')
-            user_project.new_target(:application, 'FirstTarget', :ios)
-            user_project.new_target(:application, 'UserTarget', :ios)
-
-            targets = @analyzer.send(:compute_user_project_targets, target_definition, user_project)
-            targets.map(&:name).should == ['UserTarget']
-          end
-
-          it 'raises if it is unable to find the targets specified by the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.link_with = ['UserTarget']
-            user_project = Xcodeproj::Project.new('path')
-
-            e = lambda { @analyzer.send(:compute_user_project_targets, target_definition, user_project) }.should.raise Informative
-            e.message.should.match /Unable to find the targets/
-          end
-
-          it 'returns the target with the same name of the target definition' do
-            target_definition = Podfile::TargetDefinition.new('UserTarget', nil)
-            user_project = Xcodeproj::Project.new('path')
-            user_project.new_target(:application, 'FirstTarget', :ios)
-            user_project.new_target(:application, 'UserTarget', :ios)
-
-            targets = @analyzer.send(:compute_user_project_targets, target_definition, user_project)
-            targets.map(&:name).should == ['UserTarget']
-          end
-
-          it 'raises if the name of the target definition does not match any file' do
-            target_definition = Podfile::TargetDefinition.new('UserTarget', nil)
-            user_project = Xcodeproj::Project.new('path')
-            e = lambda { @analyzer.send(:compute_user_project_targets, target_definition, user_project) }.should.raise Informative
-            e.message.should.match /Unable to find a target named/
-          end
-
-          it 'returns the first target of the project if the target definition is named default' do
-            target_definition = Podfile::TargetDefinition.new('Pods', nil)
-            target_definition.link_with_first_target = true
-            user_project = Xcodeproj::Project.new('path')
-            user_project.new_target(:application, 'FirstTarget', :ios)
-            user_project.new_target(:application, 'UserTarget', :ios)
-
-            targets = @analyzer.send(:compute_user_project_targets, target_definition, user_project)
-            targets.map(&:name).should == ['FirstTarget']
-          end
-
-          it 'raises if the default target definition cannot be linked because there are no user targets' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            user_project = Xcodeproj::Project.new('path')
-            e = lambda { @analyzer.send(:compute_user_project_targets, target_definition, user_project) }.should.raise Informative
-            e.message.should.match /Unable to find a target/
-          end
-        end
-
-        #--------------------------------------#
-
-        describe '#compute_user_build_configurations' do
-          it 'returns the user build configurations of the user targets' do
-            user_project = Xcodeproj::Project.new('path')
-            target = user_project.new_target(:application, 'Target', :ios)
-            configuration = user_project.new(Xcodeproj::Project::Object::XCBuildConfiguration)
-            configuration.name = 'AppStore'
-            target.build_configuration_list.build_configurations << configuration
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            user_targets = [target]
-
-            configurations = @analyzer.send(:compute_user_build_configurations, target_definition, user_targets)
-            configurations.should == {
-              'Debug'    => :debug,
-              'Release'  => :release,
-              'AppStore' => :release,
-            }
-          end
-
-          it 'returns the user build configurations specified in the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.build_configurations = { 'AppStore' => :release }
-            user_targets = []
-
-            configurations = @analyzer.send(:compute_user_build_configurations, target_definition, user_targets)
-            configurations.should == { 'AppStore' => :release }
-          end
-        end
-
-        #--------------------------------------#
-
-        describe '#compute_archs_for_target_definition' do
-          it 'handles a single ARCH defined in a single user target' do
-            user_project = Xcodeproj::Project.new('path')
-            target = user_project.new_target(:application, 'Target', :ios)
-            target.build_configuration_list.set_setting('ARCHS', 'armv7')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.set_platform(:ios, '4.0')
-            user_targets = [target]
-
-            archs = @analyzer.send(:compute_archs_for_target_definition, target_definition, user_targets)
-            archs.should == 'armv7'
-          end
-
-          it 'handles a single ARCH defined in multiple user targets' do
-            user_project = Xcodeproj::Project.new('path')
-            targeta = user_project.new_target(:application, 'Target', :ios)
-            targeta.build_configuration_list.set_setting('ARCHS', 'armv7')
-            targetb = user_project.new_target(:application, 'Target', :ios)
-            targetb.build_configuration_list.set_setting('ARCHS', 'armv7')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.set_platform(:ios, '4.0')
-            user_targets = [targeta, targetb]
-
-            archs = @analyzer.send(:compute_archs_for_target_definition, target_definition, user_targets)
-            archs.should == 'armv7'
-          end
-
-          it 'handles an Array of ARCHs defined in a single user target' do
-            user_project = Xcodeproj::Project.new('path')
-            target = user_project.new_target(:application, 'Target', :ios)
-            target.build_configuration_list.set_setting('ARCHS', %w(armv7 i386))
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.set_platform(:ios, '4.0')
-            user_targets = [target]
-
-            archs = @analyzer.send(:compute_archs_for_target_definition, target_definition, user_targets)
-            %w(armv7 i386).each { |a| archs.should.include a }
-          end
-
-          it 'handles an Array of ARCHs defined multiple user targets' do
-            user_project = Xcodeproj::Project.new('path')
-            targeta = user_project.new_target(:application, 'Target', :ios)
-            targeta.build_configuration_list.set_setting('ARCHS', %w(armv7 armv7s))
-            targetb = user_project.new_target(:application, 'Target', :ios)
-            targetb.build_configuration_list.set_setting('ARCHS', %w(armv7 i386))
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.set_platform(:ios, '4.0')
-            user_targets = [targeta, targetb]
-
-            archs = @analyzer.send(:compute_archs_for_target_definition, target_definition, user_targets)
-            %w(armv7 armv7s i386).each { |a| archs.should.include a }
-          end
-        end
-
-        #--------------------------------------#
-
-        describe '#compute_platform_for_target_definition' do
-          it 'returns the platform specified in the target definition' do
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            target_definition.set_platform(:ios, '4.0')
-            user_targets = []
-
-            configurations = @analyzer.send(:compute_platform_for_target_definition, target_definition, user_targets)
-            configurations.should == Platform.new(:ios, '4.0')
-          end
-
-          it 'infers the platform from the user targets' do
-            user_project = Xcodeproj::Project.new('path')
-            target = user_project.new_target(:application, 'Target', :ios)
-            target.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
-            target.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            user_targets = [target]
-
-            configurations = @analyzer.send(:compute_platform_for_target_definition, target_definition, user_targets)
-            configurations.should == Platform.new(:ios, '4.0')
-          end
-
-          it 'uses the lowest deployment target of the user targets if inferring the platform' do
-            user_project = Xcodeproj::Project.new('path')
-            target1 = user_project.new_target(:application, 'Target', :ios)
-            target1.build_configuration_list.build_configurations.first
-            target1.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
-            target1.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
-
-            target2 = user_project.new_target(:application, 'Target', :ios)
-            target2.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
-            target2.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '6.0')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            user_targets = [target1, target2]
-
-            configurations = @analyzer.send(:compute_platform_for_target_definition, target_definition, user_targets)
-            configurations.should == Platform.new(:ios, '4.0')
-          end
-
-          it 'raises if the user targets have a different platform' do
-            user_project = Xcodeproj::Project.new('path')
-            target1 = user_project.new_target(:application, 'Target', :ios)
-            target1.build_configuration_list.set_setting('SDKROOT', 'iphoneos')
-            target1.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '4.0')
-
-            target2 = user_project.new_target(:application, 'Target', :ios)
-            target2.build_configuration_list.set_setting('SDKROOT', 'macosx')
-            target2.build_configuration_list.set_setting('IPHONEOS_DEPLOYMENT_TARGET', '10.6')
-
-            target_definition = Podfile::TargetDefinition.new(:default, nil)
-            user_targets = [target1, target2]
-            e = lambda { @analyzer.send(:compute_platform_for_target_definition, target_definition, user_targets) }.should.raise Informative
-            e.message.should.match /Targets with different platforms/
-          end
-        end
-
-        #--------------------------------------#
-
         describe '#sources' do
           describe 'when there are no explicit sources' do
             it 'defaults to the master spec repository' do

spec/unit/installer/file_references_installer_spec.rb

@@ -3,10 +3,8 @@ require File.expand_path('../../../spec_helper', __FILE__)
 module Pod
   describe Installer::FileReferencesInstaller do
     before do
-      @file_accessor = fixture_file_accessor('banana-lib/BananaLib.podspec')
-      @pod_target = PodTarget.new([], nil, config.sandbox)
-      @pod_target.stubs(:platform).returns(Platform.new(:ios, '6.0'))
-      @pod_target.file_accessors = [@file_accessor]
+      @pod_target = fixture_pod_target('banana-lib/BananaLib.podspec')
+      @file_accessor = @pod_target.file_accessors.first
       @project = Project.new(config.sandbox.project_path)
       @project.add_pod_group('BananaLib', fixture('banana-lib'))
       @installer = Installer::FileReferencesInstaller.new(config.sandbox, [@pod_target], @project)
@@ -79,17 +77,17 @@ module Pod
     describe 'Private Helpers' do
       describe '#file_accessors' do
         it 'returns the file accessors' do
-          pod_target_1 = PodTarget.new([], nil, config.sandbox)
+          pod_target_1 = PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)
           pod_target_1.file_accessors = [fixture_file_accessor('banana-lib/BananaLib.podspec')]
-          pod_target_2 = PodTarget.new([], nil, config.sandbox)
+          pod_target_2 = PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)
           pod_target_2.file_accessors = [fixture_file_accessor('banana-lib/BananaLib.podspec')]
           installer = Installer::FileReferencesInstaller.new(config.sandbox, [pod_target_1, pod_target_2], @project)
           roots = installer.send(:file_accessors).map { |fa| fa.path_list.root }
           roots.should == [fixture('banana-lib'), fixture('banana-lib')]
         end
 
-        it 'handles libraries empty libraries without file accessors' do
-          pod_target_1 = PodTarget.new([], nil, config.sandbox)
+        it 'handles pods without file accessors' do
+          pod_target_1 = PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)
           pod_target_1.file_accessors = []
           installer = Installer::FileReferencesInstaller.new(config.sandbox, [pod_target_1], @project)
           installer.send(:file_accessors).should == []

spec/unit/installer/pre_install_hooks_context_spec.rb

@@ -8,7 +8,7 @@ module Pod
 
       spec = fixture_spec('banana-lib/BananaLib.podspec')
       target_definition = Podfile::TargetDefinition.new('Pods', nil)
-      pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+      pod_target = PodTarget.new([spec], [target_definition], config.sandbox)
       umbrella = AggregateTarget.new(target_definition, config.sandbox)
       umbrella.user_project_path = '/path/project.xcodeproj'
       umbrella.user_target_uuids = ['UUID']

spec/unit/installer/target_installer/aggregate_target_installer_spec.rb

@@ -28,7 +28,7 @@ module Pod
         @target.client_root = config.sandbox.root.dirname
         @target.user_build_configurations = { 'Debug' => :debug, 'Release' => :release, 'AppStore' => :release, 'Test' => :debug }
 
-        @pod_target = PodTarget.new([@spec], @target_definition, config.sandbox)
+        @pod_target = PodTarget.new([@spec], [@target_definition], config.sandbox)
         @pod_target.stubs(:platform).returns(Platform.new(:ios, '6.0'))
         @pod_target.user_build_configurations = @target.user_build_configurations
         @pod_target.file_accessors = [file_accessor]

spec/unit/installer/target_installer/pod_target_installer_spec.rb

@@ -6,7 +6,7 @@ module Pod
       before do
         config.sandbox.prepare
         @podfile = Podfile.new do
-          platform :ios
+          platform :ios, '6.0'
           xcodeproj 'dummy'
         end
         @target_definition = @podfile.target_definitions['Pods']
@@ -25,8 +25,7 @@ module Pod
           @project.add_file_reference(resource, group)
         end
 
-        @pod_target = PodTarget.new([@spec], @target_definition, config.sandbox)
-        @pod_target.stubs(:platform).returns(Platform.new(:ios, '6.0'))
+        @pod_target = PodTarget.new([@spec], [@target_definition], config.sandbox)
         @pod_target.file_accessors = [file_accessor]
         @pod_target.user_build_configurations = { 'Debug' => :debug, 'Release' => :release }
         @installer = Installer::PodTargetInstaller.new(config.sandbox, @pod_target)
@@ -34,26 +33,6 @@ module Pod
         @spec.prefix_header_contents = '#import "BlocksKit.h"'
       end
 
-      it 'adds file references for the support files of the target' do
-        @installer.install!
-        @project.support_files_group
-        group = @project['Pods/BananaLib/Support Files']
-        group.children.map(&:display_name).sort.should == [
-          'Pods-BananaLib-Private.xcconfig',
-          'Pods-BananaLib-dummy.m',
-          'Pods-BananaLib-prefix.pch',
-          'Pods-BananaLib.xcconfig',
-        ]
-      end
-
-      #--------------------------------------#
-
-      it 'adds the target for the static library to the project' do
-        @installer.install!
-        @project.targets.count.should == 1
-        @project.targets.first.name.should == 'Pods-BananaLib'
-      end
-
       it 'sets the platform and the deployment target for iOS targets' do
         @installer.install!
         target = @project.targets.first
@@ -100,15 +79,6 @@ module Pod
 
       #--------------------------------------#
 
-      it 'adds the resource bundle targets' do
-        @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
-        @installer.install!
-        bundle_target = @project.targets.find { |t| t.name == 'Pods-BananaLib-banana_bundle' }
-        bundle_target.should.be.an.instance_of Xcodeproj::Project::Object::PBXNativeTarget
-        bundle_target.product_reference.name.should == 'banana_bundle.bundle'
-        bundle_target.product_reference.path.should == 'banana_bundle.bundle'
-      end
-
       it 'adds framework resources to the framework target' do
         @pod_target.stubs(:requires_frameworks? => true)
         @installer.install!
@@ -118,14 +88,91 @@ module Pod
         resource.should.be.not.nil
       end
 
-      it 'adds the build configurations to the resources bundle targets' do
-        @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
-        @installer.install!
-        bundle_target = @project.targets.find { |t| t.name == 'Pods-BananaLib-banana_bundle' }
+      #--------------------------------------#
 
-        file = config.sandbox.root + @pod_target.xcconfig_private_path
-        bundle_target.build_configurations.each do |bc|
-          bc.base_configuration_reference.real_path.should == file
+      describe 'with a scoped pod target' do
+        before do
+          @pod_target = @pod_target.scoped.first
+          @installer = Installer::PodTargetInstaller.new(config.sandbox, @pod_target)
+        end
+
+        it 'adds file references for the support files of the target' do
+          @installer.install!
+          group = @project['Pods/BananaLib/Support Files']
+          group.children.map(&:display_name).sort.should == [
+            'Pods-BananaLib-Private.xcconfig',
+            'Pods-BananaLib-dummy.m',
+            'Pods-BananaLib-prefix.pch',
+            'Pods-BananaLib.xcconfig',
+          ]
+        end
+
+        it 'adds the target for the static library to the project' do
+          @installer.install!
+          @project.targets.count.should == 1
+          @project.targets.first.name.should == 'Pods-BananaLib'
+        end
+
+        it 'adds the resource bundle targets' do
+          @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
+          @installer.install!
+          bundle_target = @project.targets.find { |t| t.name == 'Pods-BananaLib-banana_bundle' }
+          bundle_target.should.be.an.instance_of Xcodeproj::Project::Object::PBXNativeTarget
+          bundle_target.product_reference.name.should == 'banana_bundle.bundle'
+          bundle_target.product_reference.path.should == 'banana_bundle.bundle'
+        end
+
+        it 'adds the build configurations to the resources bundle targets' do
+          @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
+          @installer.install!
+          bundle_target = @project.targets.find { |t| t.name == 'Pods-BananaLib-banana_bundle' }
+
+          file = config.sandbox.root + @pod_target.xcconfig_private_path
+          bundle_target.build_configurations.each do |bc|
+            bc.base_configuration_reference.real_path.should == file
+          end
+        end
+      end
+
+      #--------------------------------------#
+
+      describe 'with an unscoped pod target' do
+        it 'adds file references for the support files of the target' do
+          @installer.install!
+          @project.support_files_group
+          group = @project['Pods/BananaLib/Support Files']
+          group.children.map(&:display_name).sort.should == [
+            'BananaLib-Private.xcconfig',
+            'BananaLib-dummy.m',
+            'BananaLib-prefix.pch',
+            'BananaLib.xcconfig',
+          ]
+        end
+
+        it 'adds the target for the static library to the project' do
+          @installer.install!
+          @project.targets.count.should == 1
+          @project.targets.first.name.should == 'BananaLib'
+        end
+
+        it 'adds the resource bundle targets' do
+          @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
+          @installer.install!
+          bundle_target = @project.targets.find { |t| t.name == 'BananaLib-banana_bundle' }
+          bundle_target.should.be.an.instance_of Xcodeproj::Project::Object::PBXNativeTarget
+          bundle_target.product_reference.name.should == 'banana_bundle.bundle'
+          bundle_target.product_reference.path.should == 'banana_bundle.bundle'
+        end
+
+        it 'adds the build configurations to the resources bundle targets' do
+          @pod_target.file_accessors.first.stubs(:resource_bundles).returns('banana_bundle' => [])
+          @installer.install!
+          bundle_target = @project.targets.find { |t| t.name == 'BananaLib-banana_bundle' }
+
+          file = config.sandbox.root + @pod_target.xcconfig_private_path
+          bundle_target.build_configurations.each do |bc|
+            bc.base_configuration_reference.real_path.should == file
+          end
         end
       end
 
@@ -141,9 +188,7 @@ module Pod
       it "creates a prefix header, including the contents of the specification's prefix header" do
         @spec.prefix_header_contents = '#import "BlocksKit.h"'
         @installer.install!
-        support_files_dir = config.sandbox.target_support_files_dir('Pods-BananaLib')
-        prefix_header = support_files_dir + 'Pods-BananaLib-prefix.pch'
-        generated = prefix_header.read
+        generated = @pod_target.prefix_header_path.read
         expected = <<-EOS.strip_heredoc
           #ifdef __OBJC__
           #import <UIKit/UIKit.h>
@@ -157,13 +202,12 @@ module Pod
 
       it 'creates a dummy source to ensure the compilation of libraries with only categories' do
         @installer.install!
+        dummy_source_basename = @pod_target.dummy_source_path.basename.to_s
         build_files = @installer.target.native_target.source_build_phase.files
-        build_file = build_files.find { |bf| bf.file_ref.display_name == 'Pods-BananaLib-dummy.m' }
+        build_file = build_files.find { |bf| bf.file_ref.display_name == dummy_source_basename }
         build_file.should.be.not.nil
-        build_file.file_ref.path.should == 'Pods-BananaLib-dummy.m'
-        support_files_dir = config.sandbox.target_support_files_dir('Pods-BananaLib')
-        dummy = support_files_dir + 'Pods-BananaLib-dummy.m'
-        dummy.read.should.include?('@interface PodsDummy_Pods')
+        build_file.file_ref.path.should == dummy_source_basename
+        @pod_target.dummy_source_path.read.should.include?('@interface PodsDummy_BananaLib')
       end
 
       #--------------------------------------------------------------------------------#
@@ -181,7 +225,7 @@ module Pod
         end
 
         it 'flags should not be added to dtrace files' do
-          @installer.target.target_definition.stubs(:inhibits_warnings_for_pod?).returns(true)
+          @installer.target.target_definitions.first.stubs(:inhibits_warnings_for_pod?).returns(true)
           @installer.install!
 
           dtrace_files = @installer.target.native_target.source_build_phase.files.select do |sf|
@@ -193,7 +237,7 @@ module Pod
         end
 
         it 'adds -w per pod if target definition inhibits warnings for that pod' do
-          @installer.target.target_definition.stubs(:inhibits_warnings_for_pod?).returns(true)
+          @installer.target.target_definitions.first.stubs(:inhibits_warnings_for_pod?).returns(true)
           flags = @installer.send(:compiler_flags_for_consumer, @spec.consumer(:ios), true)
 
           flags.should.include?('-w')
@@ -205,7 +249,7 @@ module Pod
         end
 
         it 'adds -Xanalyzer -analyzer-disable-checker per pod' do
-          @installer.target.target_definition.stubs(:inhibits_warnings_for_pod?).returns(true)
+          @installer.target.target_definitions.first.stubs(:inhibits_warnings_for_pod?).returns(true)
           flags = @installer.send(:compiler_flags_for_consumer, @spec.consumer(:ios), true)
 
           flags.should.include?('-Xanalyzer -analyzer-disable-all-checks')

spec/unit/installer/target_installer_spec.rb

@@ -20,7 +20,7 @@ module Pod
         @project.add_file_reference(file, group)
       end
 
-      @pod_target = PodTarget.new([@spec], @target_definition, config.sandbox)
+      @pod_target = PodTarget.new([@spec], [@target_definition], config.sandbox)
       @pod_target.stubs(:platform).returns(Platform.new(:ios, '6.0'))
       @pod_target.user_build_configurations = { 'Debug' => :debug, 'Release' => :release, 'AppStore' => :release, 'Test' => :debug }
       @pod_target.file_accessors = [file_accessor]

spec/unit/installer_spec.rb

@@ -130,6 +130,10 @@ module Pod
           pod 'BananaLib',       :path => (fixture_path + 'banana-lib').to_s
           pod 'OrangeFramework', :path => (fixture_path + 'orange-framework').to_s
           pod 'monkey',          :path => (fixture_path + 'monkey').to_s
+
+          target 'TestRunner', :exclusive => true do
+            pod 'monkey',        :path => (fixture_path + 'monkey').to_s
+          end
         end
         lockfile = generate_lockfile
         config.integrate_targets = false
@@ -139,11 +143,11 @@ module Pod
 
         target = @installer.aggregate_targets.first
         target.requires_frameworks?.should == true
-        target.pod_targets.select(&:requires_frameworks?).map(&:name).sort.should == [
-          'Pods-BananaLib',
-          'Pods-OrangeFramework',
-          'Pods-monkey',
-        ]
+        target.pod_targets.select(&:requires_frameworks?).map(&:name).sort.should == %w(
+          BananaLib
+          OrangeFramework
+          monkey
+        )
       end
     end
 
@@ -261,7 +265,7 @@ module Pod
         it 'stores the targets created by the analyzer' do
           @installer.send(:analyze)
           @installer.aggregate_targets.map(&:name).sort.should == ['Pods']
-          @installer.pod_targets.map(&:name).sort.should == ['Pods-JSONKit']
+          @installer.pod_targets.map(&:name).sort.should == ['JSONKit']
         end
 
         it 'configures the analyzer to use update mode if appropriate' do
@@ -269,7 +273,7 @@ module Pod
           Installer::Analyzer.any_instance.expects(:update=).with(true)
           @installer.send(:analyze)
           @installer.aggregate_targets.map(&:name).sort.should == ['Pods']
-          @installer.pod_targets.map(&:name).sort.should == ['Pods-JSONKit']
+          @installer.pod_targets.map(&:name).sort.should == ['JSONKit']
         end
       end
 
@@ -302,7 +306,7 @@ module Pod
           @analysis_result = Installer::Analyzer::AnalysisResult.new
           @analysis_result.specifications = []
           @analysis_result.sandbox_state = Installer::Analyzer::SpecsState.new
-          @pod_targets = [PodTarget.new([], nil, config.sandbox)]
+          @pod_targets = [PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)]
           @installer.stubs(:analysis_result).returns(@analysis_result)
           @installer.stubs(:pod_targets).returns(@pod_targets)
         end
@@ -360,7 +364,7 @@ module Pod
 
         it 'correctly configures the Pod source installer' do
           spec = fixture_spec('banana-lib/BananaLib.podspec')
-          pod_target = PodTarget.new([spec], nil, config.sandbox)
+          pod_target = PodTarget.new([spec], [stub('TargetDefinition')], config.sandbox)
           pod_target.stubs(:platform).returns(:ios)
           @installer.stubs(:pod_targets).returns([pod_target])
           @installer.instance_variable_set(:@installed_specs, [])
@@ -370,7 +374,7 @@ module Pod
 
         it 'maintains the list of the installed specs' do
           spec = fixture_spec('banana-lib/BananaLib.podspec')
-          pod_target = PodTarget.new([spec], nil, config.sandbox)
+          pod_target = PodTarget.new([spec], [stub('TargetDefinition')], config.sandbox)
           pod_target.stubs(:platform).returns(:ios)
           @installer.stubs(:pod_targets).returns([pod_target, pod_target])
           @installer.instance_variable_set(:@installed_specs, [])
@@ -459,8 +463,8 @@ module Pod
         end
 
         it 'sets the deployment target for the whole project' do
-          pod_target_ios = PodTarget.new([], nil, config.sandbox)
-          pod_target_osx = PodTarget.new([], nil, config.sandbox)
+          pod_target_ios = PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)
+          pod_target_osx = PodTarget.new([stub('Spec')], [stub('TargetDefinition')], config.sandbox)
           pod_target_ios.stubs(:platform).returns(Platform.new(:ios, '6.0'))
           pod_target_osx.stubs(:platform).returns(Platform.new(:osx, '10.8'))
           aggregate_target_ios = AggregateTarget.new(nil, config.sandbox)
@@ -495,7 +499,7 @@ module Pod
           spec = fixture_spec('banana-lib/BananaLib.podspec')
           target_definition = Podfile::TargetDefinition.new(:default, nil)
           target_definition.store_pod('BananaLib')
-          pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+          pod_target = PodTarget.new([spec], [target_definition], config.sandbox)
           @installer.stubs(:aggregate_targets).returns([])
           @installer.stubs(:pod_targets).returns([pod_target])
           Installer::PodTargetInstaller.any_instance.expects(:install!)
@@ -505,7 +509,7 @@ module Pod
         it 'skips empty pod targets' do
           spec = fixture_spec('banana-lib/BananaLib.podspec')
           target_definition = Podfile::TargetDefinition.new(:default, nil)
-          pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+          pod_target = PodTarget.new([spec], [target_definition], config.sandbox)
           @installer.stubs(:aggregate_targets).returns([])
           @installer.stubs(:pod_targets).returns([pod_target])
           Installer::PodTargetInstaller.any_instance.expects(:install!).never
@@ -540,7 +544,7 @@ module Pod
           spec = fixture_spec('banana-lib/BananaLib.podspec')
 
           target_definition = Podfile::TargetDefinition.new(:default, @installer.podfile)
-          @pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+          @pod_target = PodTarget.new([spec], [target_definition], config.sandbox)
           @target = AggregateTarget.new(target_definition, config.sandbox)
 
           @mock_target = mock('PodNativeTarget')
@@ -615,15 +619,14 @@ module Pod
 
         it 'shares schemes of development pods' do
           spec = fixture_spec('banana-lib/BananaLib.podspec')
-          target_definition = Podfile::TargetDefinition.new(:default, @installer.podfile)
-          pod_target = PodTarget.new([spec], target_definition, config.sandbox)
+          pod_target = fixture_pod_target(spec)
 
-          @installer.pods_project.stubs(:targets).returns([pod_target])
+          @installer.stubs(:pod_targets).returns([pod_target])
           @installer.sandbox.stubs(:development_pods).returns('BananaLib' => nil)
 
           Xcodeproj::XCScheme.expects(:share_scheme).with(
             @installer.pods_project.path,
-            'Pods-default-BananaLib')
+            'BananaLib')
 
           @installer.send(:share_development_pod_schemes)
         end

spec/unit/target/aggregate_target_spec.rb

@@ -13,6 +13,10 @@ module Pod
         @target.target_definition.should == @target_definition
       end
 
+      it 'is initialized with empty archs' do
+        @target.archs.should == []
+      end
+
       it 'returns the label of the target definition' do
         @target.label.should == 'Pods'
       end
@@ -80,7 +84,7 @@ module Pod
       end
 
       it 'returns the path for the CONFIGURATION_BUILD_DIR build setting' do
-        @target.configuration_build_dir.should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/Pods'
+        @target.scoped_configuration_build_dir.should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/Pods'
       end
     end
 
@@ -88,7 +92,7 @@ module Pod
       before do
         @spec = fixture_spec('banana-lib/BananaLib.podspec')
         @target_definition = Podfile::TargetDefinition.new('Pods', nil)
-        @pod_target = PodTarget.new([@spec], @target_definition, config.sandbox)
+        @pod_target = PodTarget.new([@spec], [@target_definition], config.sandbox)
         @target = AggregateTarget.new(@target_definition, config.sandbox)
         @target.stubs(:platform).returns(:ios)
         @target.pod_targets = [@pod_target]
@@ -96,9 +100,9 @@ module Pod
 
       describe 'with configuration dependent pod targets' do
         before do
-          @pod_target_release = PodTarget.new([@spec], @target_definition, config.sandbox)
-          @pod_target_release.expects(:include_in_build_config?).with('Debug').returns(false)
-          @pod_target_release.expects(:include_in_build_config?).with('Release').returns(true)
+          @pod_target_release = PodTarget.new([@spec], [@target_definition], config.sandbox)
+          @pod_target_release.expects(:include_in_build_config?).with(@target_definition, 'Debug').returns(false)
+          @pod_target_release.expects(:include_in_build_config?).with(@target_definition, 'Release').returns(true)
           @target.pod_targets = [@pod_target, @pod_target_release]
           @target.user_build_configurations = {
             'Debug' => :debug,
@@ -137,7 +141,7 @@ module Pod
       describe 'With libraries' do
         before do
           @pod_target = fixture_pod_target('banana-lib/BananaLib.podspec')
-          @target = AggregateTarget.new(@pod_target.target_definition, config.sandbox)
+          @target = AggregateTarget.new(@pod_target.target_definitions.first, config.sandbox)
           @target.pod_targets = [@pod_target]
         end
 
@@ -196,8 +200,8 @@ module Pod
 
       describe 'With frameworks' do
         before do
-          @pod_target = fixture_pod_target('orange-framework/OrangeFramework.podspec', :ios, Podfile::TargetDefinition.new('iOS Example', nil))
-          @target = AggregateTarget.new(@pod_target.target_definition, config.sandbox)
+          @pod_target = fixture_pod_target('orange-framework/OrangeFramework.podspec', fixture_target_definition('iOS Example'))
+          @target = AggregateTarget.new(@pod_target.target_definitions.first, config.sandbox)
           @target.stubs(:requires_frameworks?).returns(true)
           @target.pod_targets = [@pod_target]
         end

spec/unit/target/pod_target_spec.rb

@@ -5,21 +5,42 @@ module Pod
     before do
       spec = fixture_spec('banana-lib/BananaLib.podspec')
       @target_definition = Podfile::TargetDefinition.new('Pods', nil)
-      @pod_target = PodTarget.new([spec], @target_definition, config.sandbox)
+      @pod_target = PodTarget.new([spec], [@target_definition], config.sandbox)
       @pod_target.stubs(:platform).returns(:ios)
     end
 
+    describe 'Meta' do
+      describe '#scoped' do
+        it 'returns target copies per target definition, which are scoped' do
+          @pod_target.should.not.be.scoped
+          @pod_target.scoped.first.should.be.scoped
+          @pod_target.should.not.be.scoped
+        end
+      end
+    end
+
     describe 'In general' do
-      it 'returns the target_definition that generated it' do
-        @pod_target.target_definition.should == @target_definition
+      it 'returns the target definitions' do
+        @pod_target.target_definitions.should == [@target_definition]
+      end
+
+      it 'is initialized with empty archs' do
+        @pod_target.archs.should == []
       end
 
       it 'returns its name' do
-        @pod_target.name.should == 'Pods-BananaLib'
+        @pod_target.name.should == 'BananaLib'
+        @pod_target.scoped.first.name.should == 'Pods-BananaLib'
+      end
+
+      it 'returns its label' do
+        @pod_target.label.should == 'BananaLib'
+        @pod_target.scoped.first.label.should == 'Pods-BananaLib'
       end
 
       it 'returns the name of its product' do
-        @pod_target.product_name.should == 'libPods-BananaLib.a'
+        @pod_target.product_name.should == 'libBananaLib.a'
+        @pod_target.scoped.first.product_name.should == 'libPods-BananaLib.a'
       end
 
       it 'returns the spec consumers for the pod targets' do
@@ -35,7 +56,8 @@ module Pod
       end
 
       it 'returns the name of the resources bundle target' do
-        @pod_target.resources_bundle_target_label('Fruits').should == 'Pods-BananaLib-Fruits'
+        @pod_target.resources_bundle_target_label('Fruits').should == 'BananaLib-Fruits'
+        @pod_target.scoped.first.resources_bundle_target_label('Fruits').should == 'Pods-BananaLib-Fruits'
       end
 
       it 'returns the name of the Pods on which this target depends' do
@@ -45,13 +67,13 @@ module Pod
       it 'returns whether it is whitelisted in a build configuration' do
         @target_definition.store_pod('BananaLib')
         @target_definition.whitelist_pod_for_configuration('BananaLib', 'debug')
-        @pod_target.include_in_build_config?('Debug').should.be.true
-        @pod_target.include_in_build_config?('Release').should.be.false
+        @pod_target.include_in_build_config?(@target_definition, 'Debug').should.be.true
+        @pod_target.include_in_build_config?(@target_definition, 'Release').should.be.false
       end
 
       it 'is whitelisted on all build configurations of it is a dependency of other Pods' do
-        @pod_target.include_in_build_config?('Debug').should.be.true
-        @pod_target.include_in_build_config?('Release').should.be.true
+        @pod_target.include_in_build_config?(@target_definition, 'Debug').should.be.true
+        @pod_target.include_in_build_config?(@target_definition, 'Release').should.be.true
       end
 
       it 'raises if a Pod is whitelisted for different build configurations' do
@@ -59,7 +81,7 @@ module Pod
         @target_definition.store_pod('BananaLib/Subspec')
         @target_definition.whitelist_pod_for_configuration('BananaLib', 'debug')
         message = should.raise Informative do
-          @pod_target.include_in_build_config?('release').should.be.true
+          @pod_target.include_in_build_config?(@target_definition, 'release').should.be.true
         end.message
         message.should.match /subspecs across different build configurations/
       end
@@ -84,45 +106,67 @@ module Pod
     describe 'Support files' do
       it 'returns the absolute path of the xcconfig file' do
         @pod_target.xcconfig_path('Release').to_s.should.include?(
+          'Pods/Target Support Files/BananaLib/BananaLib.release.xcconfig',
+        )
+        @pod_target.scoped.first.xcconfig_path('Release').to_s.should.include?(
           'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib.release.xcconfig',
         )
       end
 
       it 'escapes the file separators in variant build configuration name in the xcconfig file' do
         @pod_target.xcconfig_path("Release#{File::SEPARATOR}1").to_s.should.include?(
+          'Pods/Target Support Files/BananaLib/BananaLib.release-1.xcconfig',
+        )
+        @pod_target.scoped.first.xcconfig_path("Release#{File::SEPARATOR}1").to_s.should.include?(
           'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib.release-1.xcconfig',
         )
       end
 
       it 'returns the absolute path of the prefix header file' do
         @pod_target.prefix_header_path.to_s.should.include?(
+          'Pods/Target Support Files/BananaLib/BananaLib-prefix.pch',
+        )
+        @pod_target.scoped.first.prefix_header_path.to_s.should.include?(
           'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib-prefix.pch',
         )
       end
 
       it 'returns the absolute path of the bridge support file' do
         @pod_target.bridge_support_path.to_s.should.include?(
-          'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib.bridgesupport',
+          'Pods/Target Support Files/BananaLib/BananaLib.bridgesupport',
         )
       end
 
       it 'returns the absolute path of the info plist file' do
         @pod_target.info_plist_path.to_s.should.include?(
+          'Pods/Target Support Files/BananaLib/Info.plist',
+        )
+        @pod_target.scoped.first.info_plist_path.to_s.should.include?(
           'Pods/Target Support Files/Pods-BananaLib/Info.plist',
         )
       end
 
+      it 'returns the absolute path of the dummy source file' do
+        @pod_target.dummy_source_path.to_s.should.include?(
+          'Pods/Target Support Files/BananaLib/BananaLib-dummy.m',
+        )
+        @pod_target.scoped.first.dummy_source_path.to_s.should.include?(
+          'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib-dummy.m',
+        )
+      end
+
       it 'returns the absolute path of the public and private xcconfig files' do
         @pod_target.xcconfig_path.to_s.should.include?(
-          'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib.xcconfig',
+          'Pods/Target Support Files/BananaLib/BananaLib.xcconfig',
         )
         @pod_target.xcconfig_private_path.to_s.should.include(
-          'Pods/Target Support Files/Pods-BananaLib/Pods-BananaLib-Private.xcconfig',
+          'Pods/Target Support Files/BananaLib/BananaLib-Private.xcconfig',
         )
       end
 
       it 'returns the path for the CONFIGURATION_BUILD_DIR build setting' do
-        @pod_target.configuration_build_dir.should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/Pods'
+        @pod_target.configuration_build_dir.should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)'
+        @pod_target.scoped.first.configuration_build_dir.should == '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/Pods'
       end
     end
 
@@ -150,7 +194,8 @@ module Pod
           end
 
           it 'returns the library name' do
-            @pod_target.static_library_name.should == 'libPods-BananaLib.a'
+            @pod_target.static_library_name.should == 'libBananaLib.a'
+            @pod_target.scoped.first.static_library_name.should == 'libPods-BananaLib.a'
           end
 
           it 'returns :framework as product type' do
@@ -164,7 +209,8 @@ module Pod
 
         describe 'Host does not requires frameworks' do
           it 'returns the product name' do
-            @pod_target.product_name.should == 'libPods-BananaLib.a'
+            @pod_target.product_name.should == 'libBananaLib.a'
+            @pod_target.scoped.first.product_name.should == 'libPods-BananaLib.a'
           end
 
           it 'returns the framework name' do
@@ -172,7 +218,8 @@ module Pod
           end
 
           it 'returns the library name' do
-            @pod_target.static_library_name.should == 'libPods-BananaLib.a'
+            @pod_target.static_library_name.should == 'libBananaLib.a'
+            @pod_target.scoped.first.static_library_name.should == 'libPods-BananaLib.a'
           end
 
           it 'returns :static_library as product type' do
@@ -208,7 +255,8 @@ module Pod
         end
 
         it 'returns the library name' do
-          @pod_target.static_library_name.should == 'libPods-OrangeFramework.a'
+          @pod_target.static_library_name.should == 'libOrangeFramework.a'
+          @pod_target.scoped.first.static_library_name.should == 'libPods-OrangeFramework.a'
         end
 
         it 'returns :framework as product type' do