cocoapods 1.0.0.beta.3 → 1.0.0.beta.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04db614d298cf64360e2528b3a6a187fe56fae78
-  data.tar.gz: 4c179f800285b164798be255164b2dd96f8f24f5
+  metadata.gz: 6a45e8f74520fb565c87e9868bddd55dc0fb6131
+  data.tar.gz: 4f454b54f7246fe6b0b7eb3d4e46f83bf4aa8a88
 SHA512:
-  metadata.gz: 370854285b3569c125818e3b905794b5eac5487f2891aa21e19b36139143b9ad0a3e1970eca7ecb6b7b04ba5876460b502c1f65509a1bb3e05eac2ad2fbfbb57
-  data.tar.gz: c5e7ac223cbac6a558528dbc5d43e8e937f04ec2fb667cdb8a9b32c825c1671e86767ddf876c2bc439aa09ea6808d04a4e94b8ad39a58731be7726dd6ddcf41a
+  metadata.gz: 284712afd5fcad4ab68829aa9976f8c2ef64c54a3554b93c69a637807187aa56c2ce050b62219529b7db976bad9a087e415d14227c337777103bacd63074fce7
+  data.tar.gz: edc7840b2eb983949a1d45fb2688b8eb9175d070ea6f840f944ace9238024823fb75154b64e6272c12af610d74d56d99d30f0ba3c2ebe291ba4e9fb2e0a40e43

data/CHANGELOG.md

@@ -1,9 +1,49 @@
-## Installation & Update
+# Installation & Update
 
 To install or update CocoaPods see this [guide](http://docs.cocoapods.org/guides/installing_cocoapods.html).
 
 To install release candidates run `[sudo] gem install cocoapods --pre`
 
+## 1.0.0.beta.4 (2016-02-24)
+
+##### Enhancements
+
+* Allow deduplication to take effect even when the same pod is used with
+  different sets of subspecs across different platforms.
+  This changes the general naming scheme scoped pod targets. They are
+  suffixed now on base of what makes them different among others for the
+  same root spec instead of being prefixed by the dependent target.  
+  [Marius Rackwitz](https://github.com/mrackwitz)
+  [#4146](https://github.com/CocoaPods/CocoaPods/pull/4146)
+
+* Pass `COCOAPODS_VERSION` as environment variable when invoking the
+  `prepare_command`.  
+  [Marius Rackwitz](https://github.com/mrackwitz)
+  [#4933](https://github.com/CocoaPods/CocoaPods/pull/4933)
+
+##### Bug Fixes
+
+* Pods are built by default in another scoping level of the build products
+  directory identified by their name to prevent name clashes among
+  dependencies.  
+  [Marius Rackwitz](https://github.com/mrackwitz)
+  [#4146](https://github.com/CocoaPods/CocoaPods/pull/4146)
+
+* Fix mixed integrations where static libraries are used along frameworks
+  from different target definitions in one Podfile.  
+  [Marius Rackwitz](https://github.com/mrackwitz)
+  [#4146](https://github.com/CocoaPods/CocoaPods/pull/4146)
+
+* Pass target device arguments to `ibtool` in the copy resources script, fixing
+  compilation of storyboards when targeting versions of iOS prior to iOS 8.  
+  [seaders](https://github.com/seaders)
+  [#4913](https://github.com/CocoaPods/CocoaPods/issues/4913)
+
+* Fix `pod repo lint` when passed a path argument.  
+  [Boris Bügling](https://github.com/neonichu)
+  [#4883](https://github.com/CocoaPods/CocoaPods/issues/4883)
+
+
 ## 1.0.0.beta.3 (2016-02-03)
 
 ##### Breaking

data/lib/cocoapods/command/repo/lint.rb

@@ -34,17 +34,21 @@ module Pod
         # @todo add UI.print and enable print statements again.
         #
         def run
-          if @name
-            sources = SourcesManager.sources([@name])
-          else
-            sources = SourcesManager.aggregate.sources
-          end
+          sources = if @name
+                      if File.exist?(@name)
+                        [Pathname.new(@name)]
+                      else
+                        SourcesManager.sources([@name]).map(&:repo)
+                      end
+                    else
+                      SourcesManager.aggregate.sources.map(&:repo)
+                    end
 
           sources.each do |source|
-            SourcesManager.check_version_information(source.repo)
-            UI.puts "\nLinting spec repo `#{source.repo.basename}`\n".yellow
+            SourcesManager.check_version_information(source)
+            UI.puts "\nLinting spec repo `#{source.basename}`\n".yellow
 
-            validator = Source::HealthReporter.new(source.repo)
+            validator = Source::HealthReporter.new(source)
             validator.pre_check do |_name, _version|
               UI.print '.'
             end

data/lib/cocoapods/executable.rb

@@ -30,7 +30,7 @@ module Pod
 
     # Executes the given command displaying it if in verbose mode.
     #
-    # @param  [String] bin
+    # @param  [String] executable
     #         The binary to use.
     #
     # @param  [Array<#to_s>] command

data/lib/cocoapods/gem_version.rb

@@ -1,5 +1,5 @@
 module Pod
   # The version of the CocoaPods command line tool.
   #
-  VERSION = '1.0.0.beta.3'.freeze unless defined? Pod::VERSION
+  VERSION = '1.0.0.beta.4'.freeze unless defined? Pod::VERSION
 end

data/lib/cocoapods/generator/copy_resources_script.rb

@@ -106,6 +106,21 @@ RESOURCES_TO_COPY=${PODS_ROOT}/resources-to-copy-${TARGETNAME}.txt
 
 XCASSET_FILES=()
 
+case "${TARGETED_DEVICE_FAMILY}" in
+  1,2)
+    TARGET_DEVICE_ARGS="--target-device ipad --target-device iphone"
+    ;;
+  1)
+    TARGET_DEVICE_ARGS="--target-device iphone"
+    ;;
+  2)
+    TARGET_DEVICE_ARGS="--target-device ipad"
+    ;;
+  *)
+    TARGET_DEVICE_ARGS="--target-device mac"
+    ;;
+esac
+
 realpath() {
   DIRECTORY="$(cd "${1%/*}" && pwd)"
   FILENAME="${1##*/}"
@@ -127,8 +142,8 @@ EOM
   fi
   case $RESOURCE_PATH in
     *\.storyboard)
-      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .storyboard`.storyboardc $RESOURCE_PATH --sdk ${SDKROOT}"
-      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .storyboard`.storyboardc" "$RESOURCE_PATH" --sdk "${SDKROOT}"
+      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .storyboard`.storyboardc $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}"
+      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .storyboard`.storyboardc" "$RESOURCE_PATH" --sdk "${SDKROOT} ${TARGET_DEVICE_ARGS}"
       ;;
     *\.xib)
       echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .xib`.nib $RESOURCE_PATH --sdk ${SDKROOT}"
@@ -179,21 +194,6 @@ EOS
 
 if [[ -n "${WRAPPER_EXTENSION}" ]] && [ "`xcrun --find actool`" ] && [ -n "$XCASSET_FILES" ]
 then
-  case "${TARGETED_DEVICE_FAMILY}" in
-    1,2)
-      TARGET_DEVICE_ARGS="--target-device ipad --target-device iphone"
-      ;;
-    1)
-      TARGET_DEVICE_ARGS="--target-device iphone"
-      ;;
-    2)
-      TARGET_DEVICE_ARGS="--target-device ipad"
-      ;;
-    *)
-      TARGET_DEVICE_ARGS="--target-device mac"
-      ;;
-  esac
-
   # Find all other xcassets (this unfortunately includes those of path pods and other targets).
   OTHER_XCASSETS=$(find "$PWD" -iname "*.xcassets" -type d)
   while read line; do

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

@@ -59,6 +59,7 @@ module Pod
             'PODS_ROOT' => target.relative_pods_root,
             'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
             'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
+            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
           }
           if pod_targets.any?(&:uses_swift?)
             config['EMBEDDED_CONTENT_CONTAINS_SWIFT'] = 'YES'
@@ -94,15 +95,11 @@ module Pod
         #
         def settings_to_import_pod_targets
           if target.requires_frameworks?
-            framework_header_search_paths = pod_targets.select(&:should_build?).map do |target|
-              if target.scoped?
-                "$PODS_FRAMEWORK_BUILD_PATH/#{target.product_name}/Headers"
-              else
-                "$CONFIGURATION_BUILD_DIR/#{target.product_name}/Headers"
-              end
+            build_pod_targets = pod_targets.select(&:should_build?)
+            framework_header_search_paths = build_pod_targets.map do |target|
+              "#{target.build_product_path}/Headers"
             end
             build_settings = {
-              'PODS_FRAMEWORK_BUILD_PATH' => XCConfigHelper.quote([target.scoped_configuration_build_dir]),
               # Make framework headers discoverable by `import "…"`
               'OTHER_CFLAGS' => '$(inherited) ' + XCConfigHelper.quote(framework_header_search_paths, '-iquote'),
             }
@@ -112,9 +109,6 @@ module Pod
               build_settings['HEADER_SEARCH_PATHS'] = '$(inherited) ' + XCConfigHelper.quote(library_header_search_paths)
               build_settings['OTHER_CFLAGS'] += ' ' + XCConfigHelper.quote(library_header_search_paths, '-isystem')
             end
-            if pod_targets.any? { |t| t.should_build? && t.scoped? }
-              build_settings['FRAMEWORK_SEARCH_PATHS'] = '$PODS_FRAMEWORK_BUILD_PATH'
-            end
             build_settings
           else
             # Make headers discoverable from $PODS_ROOT/Headers directory
@@ -137,9 +131,11 @@ module Pod
         #  - `@import …;` / `import …`
         #
         def generate_settings_to_import_pod_targets
+          @xcconfig.merge! XCConfigHelper.settings_for_dependent_targets(target, pod_targets)
           @xcconfig.merge!(settings_to_import_pod_targets)
           target.search_paths_aggregate_targets.each do |search_paths_target|
             generator = AggregateXCConfig.new(search_paths_target, configuration_name)
+            @xcconfig.merge! XCConfigHelper.settings_for_dependent_targets(nil, search_paths_target.pod_targets)
             @xcconfig.merge!(generator.settings_to_import_pod_targets)
           end
         end

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

@@ -45,32 +45,25 @@ module Pod
           search_paths = target_search_paths.concat(sandbox_search_paths).uniq
 
           config = {
+            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
+            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
+            'HEADER_SEARCH_PATHS' => XCConfigHelper.quote(search_paths),
+            'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
             'OTHER_LDFLAGS' => XCConfigHelper.default_ld_flags(target),
             'PODS_ROOT' => '${SRCROOT}',
-            'HEADER_SEARCH_PATHS' => XCConfigHelper.quote(search_paths),
-            'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
-            'SKIP_INSTALL' => 'YES',
-            'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
             'PRODUCT_BUNDLE_IDENTIFIER' => 'org.cocoapods.${PRODUCT_NAME:rfc1034identifier}',
+            'SKIP_INSTALL' => 'YES',
             # 'USE_HEADERMAP' => 'NO'
           }
 
           @xcconfig = Xcodeproj::Config.new(config)
 
-          if target.requires_frameworks? && target.scoped?
-            build_settings = {
-              'PODS_FRAMEWORK_BUILD_PATH' => XCConfigHelper.quote([target.configuration_build_dir]),
-              'FRAMEWORK_SEARCH_PATHS' => '$PODS_FRAMEWORK_BUILD_PATH',
-              'CONFIGURATION_BUILD_DIR' => '$PODS_FRAMEWORK_BUILD_PATH',
-            }
-            @xcconfig.merge!(build_settings)
-          end
-
           XCConfigHelper.add_settings_for_file_accessors_of_target(target, @xcconfig)
           target.file_accessors.each do |file_accessor|
             @xcconfig.merge!(file_accessor.spec_consumer.pod_target_xcconfig)
           end
           XCConfigHelper.add_target_specific_settings(target, @xcconfig)
+          @xcconfig.merge! XCConfigHelper.settings_for_dependent_targets(target, target.dependent_targets)
           @xcconfig
         end
 

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

@@ -4,6 +4,13 @@ module Pod
       # Stores the shared logic of the classes of the XCConfig module.
       #
       module XCConfigHelper
+        # @return [String] Defined to hold the default Xcode build path, so
+        #         that when this is overridden per {PodTarget}, it is still
+        #         possible to reference other build products relative to the
+        #         original path.
+        #
+        SHARED_BUILD_DIR_VARIABLE = 'PODS_SHARED_BUILD_DIR'.freeze
+
         # Converts an array of strings to a single string where the each string
         # is surrounded by double quotes and separated by a space. Used to
         # represent strings in a xcconfig file.
@@ -49,6 +56,8 @@ module Pod
         # @param  [Xcodeproj::Config] xcconfig
         #         The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_settings_for_file_accessors_of_target(target, xcconfig)
           target.file_accessors.each do |file_accessor|
             XCConfigHelper.add_spec_build_settings_to_xcconfig(file_accessor.spec_consumer, xcconfig)
@@ -73,6 +82,8 @@ module Pod
         # @param [Spec::FileAccessor] file_accessor
         #        The file accessor, which holds the list of static frameworks.
         #
+        # @return [void]
+        #
         def self.add_static_dependency_build_settings(target, xcconfig, file_accessor)
           file_accessor.vendored_static_frameworks.each do |vendored_static_framework|
             XCConfigHelper.add_framework_build_settings(vendored_static_framework, xcconfig, target.sandbox.root)
@@ -90,6 +101,8 @@ module Pod
         # @param [Xcodeproj::Config] xcconfig
         #        The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_dynamic_dependency_build_settings(target, xcconfig)
           target.file_accessors.each do |file_accessor|
             file_accessor.vendored_dynamic_frameworks.each do |vendored_dynamic_framework|
@@ -110,6 +123,8 @@ module Pod
         # @param  [Xcodeproj::Config] xcconfig
         #         The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_spec_build_settings_to_xcconfig(consumer, xcconfig)
           xcconfig.libraries.merge(consumer.libraries)
           xcconfig.frameworks.merge(consumer.frameworks)
@@ -129,6 +144,8 @@ module Pod
         # @param  [Pathname] sandbox_root
         #         The path retrieved from Sandbox#root.
         #
+        # @return [void]
+        #
         def self.add_framework_build_settings(framework_path, xcconfig, sandbox_root)
           name = File.basename(framework_path, '.framework')
           dirname = '${PODS_ROOT}/' + framework_path.dirname.relative_path_from(sandbox_root).to_s
@@ -151,6 +168,8 @@ module Pod
         # @param  [Pathname] sandbox_root
         #         The path retrieved from Sandbox#root.
         #
+        # @return [void]
+        #
         def self.add_library_build_settings(library_path, xcconfig, sandbox_root)
           extension = File.extname(library_path)
           name = File.basename(library_path, extension).sub(/\Alib/, '')
@@ -172,6 +191,8 @@ module Pod
         # @param  [Xcodeproj::Config] xcconfig
         #         The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_code_signing_settings(target, xcconfig)
           build_settings = {}
           if target.platform.to_sym == :osx
@@ -189,6 +210,8 @@ module Pod
         # @param  [Xcodeproj::Config] xcconfig
         #         The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_target_specific_settings(target, xcconfig)
           if target.requires_frameworks?
             add_code_signing_settings(target, xcconfig)
@@ -196,6 +219,46 @@ module Pod
           add_language_specific_settings(target, xcconfig)
         end
 
+        # Returns the search paths for frameworks and libraries the given target
+        # depends on, so that it can be correctly built and linked.
+        #
+        # @param  [Target] target
+        #         The target.
+        #
+        # @param  [Array<PodTarget>] dependent_targets
+        #         The pod targets the given target depends on.
+        #
+        # @return [Hash<String, String>] the settings
+        #
+        def self.settings_for_dependent_targets(target, dependent_targets)
+          dependent_targets = dependent_targets.select(&:should_build?)
+          has_configuration_build_dir = target.respond_to?(:configuration_build_dir)
+          if has_configuration_build_dir
+            build_dir_var = "$#{SHARED_BUILD_DIR_VARIABLE}"
+            build_settings = {
+              'CONFIGURATION_BUILD_DIR' => target.configuration_build_dir(build_dir_var),
+              SHARED_BUILD_DIR_VARIABLE => '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)',
+            }
+          else
+            build_dir_var = '$CONFIGURATION_BUILD_DIR'
+            build_settings = {}
+          end
+          unless dependent_targets.empty?
+            framework_search_paths = []
+            library_search_paths = []
+            dependent_targets.each do |dependent_target|
+              if dependent_target.requires_frameworks?
+                framework_search_paths << dependent_target.configuration_build_dir(build_dir_var)
+              else
+                library_search_paths << dependent_target.configuration_build_dir(build_dir_var)
+              end
+            end
+            build_settings['FRAMEWORK_SEARCH_PATHS'] = XCConfigHelper.quote(framework_search_paths.uniq)
+            build_settings['LIBRARY_SEARCH_PATHS']   = XCConfigHelper.quote(library_search_paths.uniq)
+          end
+          build_settings
+        end
+
         # Checks if the given target requires language specific settings and
         # configures the given Xcconfig.
         #
@@ -205,6 +268,8 @@ module Pod
         # @param  [Xcodeproj::Config] xcconfig
         #         The xcconfig to edit.
         #
+        # @return [void]
+        #
         def self.add_language_specific_settings(target, xcconfig)
           if target.uses_swift?
             build_settings = {

data/lib/cocoapods/installer.rb

@@ -108,7 +108,6 @@ module Pod
       prepare
       resolve_dependencies
       download_dependencies
-      determine_dependency_product_types
       verify_no_duplicate_framework_names
       verify_no_static_framework_transitive_dependencies
       verify_framework_usage
@@ -376,22 +375,6 @@ module Pod
       end
     end
 
-    # Determines if the dependencies need to be built as dynamic frameworks or
-    # if they can be built as static libraries by checking for the Swift source
-    # presence. Therefore it is important that the file accessors of the
-    # #pod_targets are created.
-    #
-    # @return [void]
-    #
-    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.platform = nil # needs to be recomputed
-        end
-      end
-    end
-
     def verify_no_duplicate_framework_names
       aggregate_targets.each do |aggregate_target|
         aggregate_target.user_build_configurations.keys.each do |config|
@@ -629,13 +612,11 @@ module Pod
     def install_libraries
       UI.message '- Installing targets' do
         pod_targets.sort_by(&:name).each do |pod_target|
-          next if pod_target.target_definitions.all?(&:abstract?)
           target_installer = PodTargetInstaller.new(sandbox, pod_target)
           target_installer.install!
         end
 
         aggregate_targets.sort_by(&:name).each do |target|
-          next if target.target_definition.abstract?
           target_installer = AggregateTargetInstaller.new(sandbox, target)
           target_installer.install!
         end
@@ -679,23 +660,15 @@ module Pod
           aggregate_target.native_target.add_dependency(pod_target.native_target)
           configure_app_extension_api_only_for_target(pod_target) if is_app_extension
 
-          pod_target.dependencies.each do |dep|
-            unless dep == pod_target.pod_name
-              pod_dependency_target = aggregate_target.pod_targets.find { |target| target.pod_name == dep }
-              # TODO: remove me
-              unless pod_dependency_target
-                puts "[BUG] DEP: #{dep}"
-              end
-
-              next unless pod_dependency_target.should_build?
-              pod_target.native_target.add_dependency(pod_dependency_target.native_target)
-              configure_app_extension_api_only_for_target(pod_dependency_target) if is_app_extension
+          pod_target.dependent_targets.each do |pod_dependency_target|
+            next unless pod_dependency_target.should_build?
+            pod_target.native_target.add_dependency(pod_dependency_target.native_target)
+            configure_app_extension_api_only_for_target(pod_dependency_target) if is_app_extension
 
-              if pod_target.requires_frameworks?
-                product_ref = frameworks_group.files.find { |f| f.path == pod_dependency_target.product_name } ||
-                  frameworks_group.new_product_ref_for_target(pod_dependency_target.product_basename, pod_dependency_target.product_type)
-                pod_target.native_target.frameworks_build_phase.add_file_reference(product_ref, true)
-              end
+            if pod_target.requires_frameworks?
+              product_ref = frameworks_group.files.find { |f| f.path == pod_dependency_target.product_name } ||
+                frameworks_group.new_product_ref_for_target(pod_dependency_target.product_basename, pod_dependency_target.product_type)
+              pod_target.native_target.frameworks_build_phase.add_file_reference(product_ref, true)
             end
           end
         end

data/lib/cocoapods/installer/analyzer.rb

@@ -13,6 +13,8 @@ module Pod
       autoload :SandboxAnalyzer,           'cocoapods/installer/analyzer/sandbox_analyzer'
       autoload :SpecsState,                'cocoapods/installer/analyzer/specs_state'
       autoload :LockingDependencyAnalyzer, 'cocoapods/installer/analyzer/locking_dependency_analyzer'
+      autoload :PodVariant,                'cocoapods/installer/analyzer/pod_variant'
+      autoload :PodVariantSet,             'cocoapods/installer/analyzer/pod_variant_set'
       autoload :TargetInspectionResult,    'cocoapods/installer/analyzer/target_inspection_result'
       autoload :TargetInspector,           'cocoapods/installer/analyzer/target_inspector'
 
@@ -228,8 +230,9 @@ module Pod
       # @return [Array<AggregateTarget>]
       #
       def generate_targets
-        pod_targets = generate_pod_targets(result.specs_by_target)
-        aggregate_targets = result.specs_by_target.keys.reject(&:abstract?).map do |target_definition|
+        specs_by_target = result.specs_by_target.reject { |td, _| td.abstract? }
+        pod_targets = generate_pod_targets(specs_by_target)
+        aggregate_targets = specs_by_target.keys.map do |target_definition|
           generate_target(target_definition, pod_targets)
         end
         aggregate_targets.each do |target|
@@ -286,85 +289,84 @@ module Pod
       # @return [Array<PodTarget>]
       #
       def generate_pod_targets(specs_by_target)
-        dedupe_cache = {}
         if installation_options.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]
+          distinct_targets = specs_by_target.each_with_object({}) do |dependency, hash|
+            target_definition, dependent_specs = *dependency
+            dependent_specs.group_by(&:root).each do |root_spec, specs|
+              pod_variant = PodVariant.new(specs, target_definition.platform, target_definition.uses_frameworks?)
+              hash[root_spec] ||= {}
+              (hash[root_spec][pod_variant] ||= []) << 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.flat_map do |distinctor, target_definitions|
-                specs, = *distinctor
-                generate_pod_target(target_definitions, specs).scoped(dedupe_cache)
-              end
-            else
-              (specs, _), target_definitions = targets_by_distinctors.first
-              generate_pod_target(target_definitions, specs)
+          pod_targets = distinct_targets.flat_map do |_root, target_definitions_by_variant|
+            suffixes = PodVariantSet.new(target_definitions_by_variant.keys).scope_suffixes
+            target_definitions_by_variant.flat_map do |variant, target_definitions|
+              generate_pod_target(target_definitions, variant.specs, :scope_suffix => suffixes[variant])
             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)
-            target.dependent_targets = dependent_targets
-            if dependent_targets.any?(&:scoped?)
-              target.scoped(dedupe_cache)
-            else
-              target
+          all_specs = specs_by_target.values.flatten.uniq
+          pod_targets_by_name = pod_targets.group_by(&:pod_name).each_with_object({}) do |(name, values), hash|
+            # Sort the target by the number of activated subspecs, so that
+            # we prefer a minimal target as transitive dependency.
+            hash[name] = values.sort_by { |pt| pt.specs.count }
+          end
+          pod_targets.each do |target|
+            dependencies = transitive_dependencies_for_specs(target.specs, target.platform, all_specs).group_by(&:root)
+            target.dependent_targets = dependencies.map do |root_spec, deps|
+              pod_targets_by_name[root_spec.name].find do |t|
+                next false if t.platform.symbolic_name != target.platform.symbolic_name ||
+                    t.requires_frameworks? != target.requires_frameworks?
+                spec_names = t.specs.map(&:name)
+                deps.all? { |dep| spec_names.include?(dep.name) }
+              end
             end
           end
         else
-          pod_targets = 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|
+          dedupe_cache = {}
+          specs_by_target.flat_map do |target_definition, specs|
+            grouped_specs = specs.group_by(&:root).values.uniq
+            pod_targets = grouped_specs.flat_map do |pod_specs|
               generate_pod_target([target_definition], pod_specs).scoped(dedupe_cache)
             end
-          end
-          pod_targets.each do |target|
-            target.dependent_targets = transitive_dependencies_for_pod_target(target, pod_targets)
+
+            pod_targets.each do |target|
+              dependencies = transitive_dependencies_for_specs(target.specs, target.platform, specs).group_by(&:root)
+              target.dependent_targets = pod_targets.reject { |t| dependencies[t.root_spec].nil? }
+            end
           end
         end
       end
 
-      # Finds the names of the Pods upon which the given target _transitively_
-      # depends.
+      # Returns the specs upon which the given specs _transitively_ depend.
       #
       # @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<Specification>] specs
+      #         The specs, whose dependencies should be returned.
       #
-      # @param  [Array<PodTarget>] targets
-      #         All pod targets, which are integrated alongside.
+      # @param  [Platform] platform
+      #         The platform for which the dependencies should be returned.
       #
-      # @return [Array<PodTarget>]
+      # @param  [Array<Specification>] all_specs
+      #         All specifications which are installed alongside.
       #
-      def transitive_dependencies_for_pod_target(pod_target, targets)
-        if targets.any?
-          dependent_targets = pod_target.dependencies.flat_map do |dep|
-            next [] if pod_target.pod_name == 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
-          dependent_targets.uniq
-        else
-          []
-        end
+      # @return [Array<Specification>]
+      #
+      def transitive_dependencies_for_specs(specs, platform, all_specs)
+        return [] if specs.empty? || all_specs.empty?
+        dependent_specs = specs.flat_map do |spec|
+          spec.consumer(platform).dependencies.flat_map do |dependency|
+            all_specs.find do |s|
+              next false if specs.include?(s)
+              s.name == dependency.name
+            end
+          end.compact
+        end.uniq
+        remaining_specs = all_specs - dependent_specs
+        dependent_specs + transitive_dependencies_for_specs(dependent_specs, platform, remaining_specs)
       end
 
       # Create a target for each spec group
@@ -372,13 +374,17 @@ module Pod
       # @param  [TargetDefinitions] target_definitions
       #         the aggregate target
       #
-      # @param  [Array<Specification>] specs
+      # @param  [Array<Specification>] pod_specs
       #         the specifications of an equal root.
       #
+      # @param  [String] scope_suffix
+      #         @see PodTarget#scope_suffix
+      #
       # @return [PodTarget]
       #
-      def generate_pod_target(target_definitions, pod_specs)
-        pod_target = PodTarget.new(pod_specs, target_definitions, sandbox)
+      def generate_pod_target(target_definitions, pod_specs, scope_suffix: nil)
+        pod_target = PodTarget.new(pod_specs, target_definitions, sandbox, scope_suffix)
+        pod_target.host_requires_frameworks = target_definitions.any?(&:uses_frameworks?)
 
         if installation_options.integrate_targets?
           target_inspections = result.target_inspections.select { |t, _| target_definitions.include?(t) }.values

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

@@ -21,8 +21,8 @@ module Pod
         #
         attr_accessor :sandbox_state
 
-        # @return [Array<Target>] The Podfile targets containing library
-        #         dependencies.
+        # @return [Array<AggregateTarget>] The aggregate targets created for each
+        #         {TargetDefinition} from the {Podfile}.
         #
         attr_accessor :targets
 

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

@@ -0,0 +1,59 @@
+module Pod
+  class Installer
+    class Analyzer
+      # Bundles the information needed to setup a {PodTarget}.
+      class PodVariant
+        # @return [Array<Specification>] the spec and subspecs for the target
+        #
+        attr_accessor :specs
+
+        # @return [Platform] the platform
+        #
+        attr_accessor :platform
+
+        # @return [Bool] whether this pod should be built as framework
+        #
+        attr_accessor :requires_frameworks
+        alias_method :requires_frameworks?, :requires_frameworks
+
+        # @return [Specification] the root specification
+        #
+        def root_spec
+          specs.first.root
+        end
+
+        # Initialize a new instance from its attributes.
+        #
+        # @param [Array<String>] specs       @see #specs
+        # @param [Platform] platform         @see #platform
+        # @param [Bool] requires_frameworks  @see #requires_frameworks?
+        #
+        def initialize(specs, platform, requires_frameworks = false)
+          self.specs = specs
+          self.platform = platform
+          self.requires_frameworks = requires_frameworks
+        end
+
+        # @return [Bool] whether the {PodVariant} is equal to another taking all
+        #         all their attributes into account
+        #
+        def ==(other)
+          self.class == other.class &&
+            specs == other.specs &&
+            platform == other.platform &&
+            requires_frameworks == other.requires_frameworks
+        end
+        alias_method :eql?, :==
+
+        # Hashes the instance by all its attributes.
+        #
+        # This adds support to make instances usable as Hash keys.
+        #
+        # @!visibility private
+        def hash
+          [specs, platform, requires_frameworks].hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+require 'set'
+
+module Pod
+  class Installer
+    class Analyzer
+      # Collects all {PodVariant}.
+      class PodVariantSet
+        # @return [Array<PodVariant>] the different variants.
+        #
+        attr_accessor :variants
+
+        # Initialize a new instance.
+        #
+        # @param [Array<PodVariant>] variants  @see #variants
+        #
+        def initialize(variants)
+          self.variants = variants
+        end
+
+        # Describes what makes each {PodVariant} distinct among the others.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_suffixes
+          return { variants.first => nil } if variants.count == 1
+          scope_by_specs
+        end
+
+        # Groups the collection by result of the block.
+        #
+        # @param [Block<Variant, #hash>] block
+        # @return [Array<PodVariantSet>]
+        #
+        def group_by(&block)
+          variants.group_by(&block).map { |_, v| PodVariantSet.new(v) }
+        end
+
+        # @private
+        #
+        # Prepends the given scoped {PodVariant}s with another scoping label, if there
+        # was more than one group of {PodVariant}s given.
+        #
+        # @param [Array<Hash<PodVariant, String>>] scoped_variants
+        #        {PodVariant}s, which where grouped on base of a criteria, which is used
+        #        in the block argument to generate a descriptive label.
+        #
+        # @param [Block<PodVariant, String>] block
+        #        takes a {PodVariant} and returns a scope suffix which is prepended, if
+        #        necessary.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_if_necessary(scoped_variants, &block)
+          if scoped_variants.count == 1
+            return scoped_variants.first
+          end
+          Hash[scoped_variants.flat_map do |variants|
+            variants.map do |variant, suffix|
+              prefix = block.call(variant)
+              scope = [prefix, suffix].compact.join('-')
+              [variant, !scope.empty? ? scope : nil]
+            end
+          end]
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_build_type
+          scope_if_necessary(group_by(&:requires_frameworks).map(&:scope_by_platform)) do |variant|
+            variant.requires_frameworks? ? 'framework' : 'library'
+          end
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_platform
+          grouped_variants = group_by { |v| v.platform.name }
+          if grouped_variants.all? { |set| set.variants.count == 1 }
+            # => Platform name
+            platform_name_proc = proc { |v| Platform.string_name(v.platform.symbolic_name).tr(' ', '') }
+          else
+            grouped_variants = group_by(&:platform)
+            # => Platform name + SDK version
+            platform_name_proc = proc { |v| v.platform.to_s.tr(' ', '') }
+          end
+          scope_if_necessary(grouped_variants.map(&:scope_without_suffix), &platform_name_proc)
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_specs
+          root_spec = variants.first.root_spec
+          specs = [root_spec]
+          if root_spec.default_subspecs.empty?
+            specs += root_spec.subspecs.compact
+          else
+            specs += root_spec.default_subspecs.map do |subspec_name|
+              root_spec.subspec_by_name("#{root_spec.name}/#{subspec_name}")
+            end
+          end
+          default_specs = Set.new(specs)
+          grouped_variants = group_by(&:specs)
+          all_spec_variants = grouped_variants.map { |set| set.variants.first.specs }
+          common_specs = all_spec_variants.map(&:to_set).flatten.inject(&:&)
+          omit_common_specs = common_specs.any? && common_specs.proper_superset?(default_specs)
+          scope_if_necessary(grouped_variants.map(&:scope_by_build_type)) do |variant|
+            specs = variant.specs.to_set
+
+            # The current variant contains all default specs
+            omit_default_specs = default_specs.any? && default_specs.subset?(specs)
+            if omit_default_specs
+              specs -= default_specs
+            end
+
+            # There are common specs, which are different from the default specs
+            if omit_common_specs
+              specs -= common_specs
+            end
+
+            spec_names = specs.map do |spec|
+              spec.root? ? '.root' : spec.name.split('/')[1..-1].join('_')
+            end.sort
+            if spec_names.empty?
+              omit_common_specs ? '.common' : nil
+            else
+              if omit_common_specs
+                spec_names.unshift('.common')
+              elsif omit_default_specs
+                spec_names.unshift('.default')
+              end
+              spec_names.reduce('') do |acc, name|
+                "#{acc}#{acc.empty? || name[0] == '.' ? '' : '-'}#{name}"
+              end
+            end
+          end
+        end
+
+        # @private
+        #
+        # Helps to define scope suffixes recursively.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_without_suffix
+          Hash[variants.map { |v| [v, nil] }]
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/pod_source_preparer.rb

@@ -58,10 +58,15 @@ module Pod
         return unless spec.prepare_command
         UI.section(' > Running prepare command', '', 1) do
           Dir.chdir(path) do
-            ENV.delete('CDPATH')
-            prepare_command = spec.prepare_command.strip_heredoc.chomp
-            full_command = "\nset -e\n" + prepare_command
-            bash!('-c', full_command)
+            begin
+              ENV.delete('CDPATH')
+              ENV['COCOAPODS_VERSION'] = Pod::VERSION
+              prepare_command = spec.prepare_command.strip_heredoc.chomp
+              full_command = "\nset -e\n" + prepare_command
+              bash!('-c', full_command)
+            ensure
+              ENV.delete('COCOAPODS_VERSION')
+            end
           end
         end
       end

data/lib/cocoapods/installer/target_installer/aggregate_target_installer.rb

@@ -151,7 +151,7 @@ module Pod
           end
           frameworks_by_config[config] = relevant_pod_targets.flat_map do |pod_target|
             frameworks = pod_target.file_accessors.flat_map(&:vendored_dynamic_artifacts).map { |fw| "${PODS_ROOT}/#{fw.relative_path_from(sandbox.root)}" }
-            frameworks << "#{target_definition.label}/#{pod_target.product_name}" if pod_target.should_build? && pod_target.requires_frameworks?
+            frameworks << pod_target.build_product_path if pod_target.should_build? && pod_target.requires_frameworks?
             frameworks
           end
         end

data/lib/cocoapods/installer/user_project_integrator.rb

@@ -216,7 +216,7 @@ module Pod
       end
 
       def targets_to_integrate
-        targets.reject { |target| target.target_definition.abstract? }
+        targets
       end
 
       # Prints a warning informing the user that a build configuration of

data/lib/cocoapods/target/aggregate_target.rb

@@ -13,6 +13,7 @@ module Pod
     # @param [Sandbox] sandbox @see sandbox
     #
     def initialize(target_definition, sandbox)
+      raise "Can't initialize an AggregateTarget with an abstract TargetDefinition" if target_definition.abstract?
       super()
       @target_definition = target_definition
       @sandbox = sandbox
@@ -205,13 +206,6 @@ 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

data/lib/cocoapods/target/pod_target.rb

@@ -19,19 +19,25 @@ module Pod
     # @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.
+    # @note   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
+    def scoped?
+      !scope_suffix.nil?
+    end
+
+    # @return [String] used for the label and the directory name, which is used to
+    #         scope the build product in the default configuration build dir.
+    #
+    attr_reader :scope_suffix
 
     # @return [Array<PodTarget>] the targets that this target has a dependency
     #         upon.
@@ -41,16 +47,18 @@ module Pod
     # @param [Array<Specification>] @spec #see spec
     # @param [Array<TargetDefinition>] target_definitions @see target_definitions
     # @param [Sandbox] sandbox @see sandbox
-    # @param [Bool] scoped @see scoped
+    # @param [String] scope_suffix @see scope_suffix
     #
-    def initialize(specs, target_definitions, sandbox, scoped = false)
+    def initialize(specs, target_definitions, sandbox, scope_suffix = nil)
       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?
+      raise "Can't initialize a PodTarget with only abstract TargetDefinitions" if target_definitions.all?(&:abstract?)
+      raise "Can't initialize a PodTarget with an empty string scope suffix!" if scope_suffix == ''
       super()
       @specs = specs
       @target_definitions = target_definitions
       @sandbox = sandbox
-      @scoped = scoped
+      @scope_suffix = scope_suffix
       @build_headers  = Sandbox::HeadersStore.new(sandbox, 'Private')
       @file_accessors = []
       @resource_bundle_targets = []
@@ -67,7 +75,7 @@ module Pod
         if cache[cache_key]
           cache[cache_key]
         else
-          target = PodTarget.new(specs, [target_definition], sandbox, true)
+          target = PodTarget.new(specs, [target_definition], sandbox, target_definition.label)
           target.file_accessors = file_accessors
           target.user_build_configurations = user_build_configurations
           target.native_target = native_target
@@ -82,7 +90,11 @@ module Pod
     #
     def label
       if scoped?
-        "#{target_definitions.first.label}-#{root_spec.name}"
+        if scope_suffix[0] == '.'
+          "#{root_spec.name}#{scope_suffix}"
+        else
+          "#{root_spec.name}-#{scope_suffix}"
+        end
       else
         root_spec.name
       end
@@ -241,15 +253,24 @@ module Pod
       end
     end
 
-    # @return [String] The configuration build dir, relevant if the target is
-    #         integrated as framework.
+    # @param  [String] dir
+    #         The directory (which might be a variable) relative to which
+    #         the returned path should be. This must be used if the
+    #         $CONFIGURATION_BUILD_DIR is modified.
     #
-    def configuration_build_dir
-      if scoped?
-        "$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)/#{target_definitions.first.label}"
-      else
-        '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)'
-      end
+    # @return [String] The absolute path to the configuration build dir
+    #
+    def configuration_build_dir(dir = '$CONFIGURATION_BUILD_DIR')
+      "#{dir}/#{label}"
+    end
+
+    # @param  [String] dir
+    #         @see #configuration_build_dir
+    #
+    # @return [String] The absolute path to the build product
+    #
+    def build_product_path(dir = '$CONFIGURATION_BUILD_DIR')
+      "#{configuration_build_dir(dir)}/#{product_name}"
     end
 
     private

data/lib/cocoapods/user_interface/error_report.rb

@@ -65,20 +65,31 @@ EOS
         end
 
         def stack
-          <<-EOS
+          parts = {
+            'CocoaPods' => Pod::VERSION,
+            'Ruby' => RUBY_DESCRIPTION,
+            'RubyGems' => Gem::VERSION,
+            'Host' => host_information,
+            'Xcode' => xcode_information,
+            'Git' => git_information,
+            'Ruby lib dir' => RbConfig::CONFIG['libdir'],
+            'Repositories' => repo_information,
+          }
+          justification = parts.keys.map(&:size).max
+
+          str = <<-EOS
 ### Stack
 
-```
-   CocoaPods : #{Pod::VERSION}
-        Ruby : #{RUBY_DESCRIPTION}
-    RubyGems : #{Gem::VERSION}
-        Host : #{host_information}
-       Xcode : #{xcode_information}
-         Git : #{git_information}
-Ruby lib dir : #{RbConfig::CONFIG['libdir']}
-Repositories : #{repo_information.join("\n               ")}
 ```
 EOS
+          parts.each do |name, value|
+            str << name.rjust(justification)
+            str << ' : '
+            str << Array(value).join("\n" << (' ' * (justification + 3)))
+            str << "\n"
+          end
+
+          str << "```\n"
         end
 
         def plugins_string

data/lib/cocoapods/validator.rb

@@ -428,7 +428,7 @@ module Pod
     # for all available platforms with xcodebuild.
     #
     def install_pod
-      %i(determine_dependency_product_types verify_no_duplicate_framework_names
+      %i(verify_no_duplicate_framework_names
          verify_no_static_framework_transitive_dependencies
          verify_framework_usage generate_pods_project integrate_user_project
          perform_post_install_actions).each { |m| @installer.send(m) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.3
+  version: 1.0.0.beta.4
 platform: ruby
 authors:
 - Eloy Duran
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-02 00:00:00.000000000 Z
+date: 2016-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocoapods-core
@@ -19,14 +19,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.3
+        version: 1.0.0.beta.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.3
+        version: 1.0.0.beta.4
 - !ruby/object:Gem::Dependency
   name: claide
   requirement: !ruby/object:Gem::Requirement
@@ -193,21 +193,21 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: xcodeproj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.1
+        version: 1.0.0.beta.3
     - - <
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -217,7 +217,7 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.1
+        version: 1.0.0.beta.3
     - - <
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -415,6 +415,8 @@ files:
 - lib/cocoapods/installer/analyzer.rb
 - lib/cocoapods/installer/analyzer/analysis_result.rb
 - lib/cocoapods/installer/analyzer/locking_dependency_analyzer.rb
+- lib/cocoapods/installer/analyzer/pod_variant.rb
+- lib/cocoapods/installer/analyzer/pod_variant_set.rb
 - lib/cocoapods/installer/analyzer/sandbox_analyzer.rb
 - lib/cocoapods/installer/analyzer/specs_state.rb
 - lib/cocoapods/installer/analyzer/target_inspection_result.rb