cocoapods 1.8.4 → 1.9.0.beta.1

data/lib/cocoapods/installer/analyzer.rb

@@ -337,7 +337,7 @@ module Pod
         cli_host_with_frameworks = []
         cli_product_type = 'com.apple.product-type.tool'
         # Collect aggregate target definitions by uuid to later lookup host target
-        # definitions and verify their compatiblity with their embedded targets
+        # definitions and verify their compatibility with their embedded targets
         aggregate_targets.each do |target|
           target.user_targets.each do |user_target|
             target_definitions_by_uuid[user_target.uuid] = target.target_definition
@@ -415,11 +415,11 @@ module Pod
 
       # Creates the models that represent the targets generated by CocoaPods.
       #
-      # @param  [Hash{Podfile::TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
+      # @param  [Hash{TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
       #         mapping of targets to resolved specs (containing information about test usage)
       #         aggregate targets
       #
-      # @param  [Array<TargetInspection>] target_inspections
+      # @param  [Hash{TargetDefinition => TargetInspectionResult}] target_inspections
       #         the user target inspections used to construct the aggregate and pod targets.
       #
       # @return [(Array<AggregateTarget>, Array<PodTarget>)] the list of aggregate targets generated,
@@ -442,7 +442,9 @@ module Pod
         aggregate_targets.each do |aggregate_target|
           is_app_extension = !(aggregate_target.user_targets.map(&:symbol_type) &
               [:app_extension, :watch_extension, :watch2_extension, :tv_extension, :messages_extension]).empty?
-          is_app_extension ||= aggregate_target.user_targets.any? { |ut| ut.common_resolved_build_setting('APPLICATION_EXTENSION_API_ONLY') == 'YES' }
+          is_app_extension ||= aggregate_target.user_targets.any? do |user_target|
+            user_target.common_resolved_build_setting('APPLICATION_EXTENSION_API_ONLY', :resolve_against_xcconfig => true) == 'YES'
+          end
 
           next unless is_app_extension
 
@@ -456,7 +458,7 @@ module Pod
           embedded_targets = aggregate_targets.select(&:requires_host_target?)
           analyze_host_targets_in_podfile(aggregate_targets, embedded_targets)
 
-          use_frameworks_embedded_targets, non_use_frameworks_embedded_targets = embedded_targets.partition(&:host_requires_frameworks?)
+          use_frameworks_embedded_targets, non_use_frameworks_embedded_targets = embedded_targets.partition(&:build_as_framework?)
           aggregate_targets = aggregate_targets.map do |aggregate_target|
             # For targets that require dynamic frameworks, we always have to copy their pods to their
             # host targets because those frameworks will all be loaded from the host target's bundle
@@ -481,7 +483,7 @@ module Pod
       # @param  [Hash{TargetDefinition => TargetInspectionResult}] target_inspections
       #         the user target inspections used to construct the aggregate and pod targets.
       #
-      # @param  [Hash{Podfile::TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
+      # @param  [Hash{TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
       #         the pod targets grouped by target.
       #
       # @return [AggregateTarget]
@@ -506,13 +508,12 @@ module Pod
         end
         platform = target_definition.platform
         build_configurations = user_build_configurations.keys.concat(target_definition.all_whitelisted_configurations).uniq
-        pod_targets_for_build_configuration = filter_pod_targets_for_target_definition(target_definition, pod_targets_by_target_definition,
+        pod_targets_for_build_configuration = filter_pod_targets_for_target_definition(target_definition,
+                                                                                       pod_targets_by_target_definition,
                                                                                        build_configurations)
-
-        build_type = target_definition.uses_frameworks? ? Target::BuildType.static_framework : Target::BuildType.static_library
-        AggregateTarget.new(sandbox, target_definition.uses_frameworks?, user_build_configurations, archs, platform,
-                            target_definition, client_root, user_project, user_target_uuids,
-                            pod_targets_for_build_configuration, :build_type => build_type)
+        build_type = target_definition.uses_frameworks? ? BuildType.static_framework : BuildType.static_library
+        AggregateTarget.new(sandbox, build_type, user_build_configurations, archs, platform, target_definition,
+                            client_root, user_project, user_target_uuids, pod_targets_for_build_configuration)
       end
 
       # Returns a filtered list of pod targets that should or should not be part of the target definition. Pod targets
@@ -542,16 +543,17 @@ module Pod
       # @param [TargetDefinition] target_definition
       #        the target definition to use as the base for filtering
       #
-      # @param  [Hash{Podfile::TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
+      # @param  [Hash{TargetDefinition => Array<PodTarget>}] pod_targets_by_target_definition
       #         the pod targets grouped by target.
       #
       # @param  [Array<String>] build_configurations
       #         The list of all build configurations the targets will be built for.
       #
-      # @return [Hash<String => Array<PodTarget>>]
+      # @return [Hash{String => Array<PodTarget>}]
       #         the filtered list of pod targets, grouped by build configuration.
       #
-      def filter_pod_targets_for_target_definition(target_definition, pod_targets_by_target_definition, build_configurations)
+      def filter_pod_targets_for_target_definition(target_definition, pod_targets_by_target_definition,
+                                                   build_configurations)
         pod_targets_by_build_config = Hash.new([].freeze)
         build_configurations.each { |config| pod_targets_by_build_config[config] = [] }
 
@@ -588,7 +590,7 @@ module Pod
       # targets by grouping by platform and subspec by their root
       # to create a {PodTarget} for each spec.
       #
-      # @param  [Hash{Podfile::TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
+      # @param  [Hash{TargetDefinition => Array<ResolvedSpecification>}] resolver_specs_by_target
       #         the resolved specifications grouped by target.
       #
       # @param  [Hash{TargetDefinition => TargetInspectionResult}] target_inspections
@@ -606,8 +608,8 @@ module Pod
               library_specs = all_specs_by_type[:library] || []
               test_specs = all_specs_by_type[:test] || []
               app_specs = all_specs_by_type[:app] || []
-              target_type = Target::BuildType.infer_from_spec(root_spec, :host_requires_frameworks => target_definition.uses_frameworks?)
-              pod_variant = PodVariant.new(library_specs, test_specs, app_specs, target_definition.platform, target_type)
+              build_type = determine_build_type(root_spec, target_definition.build_type)
+              pod_variant = PodVariant.new(library_specs, test_specs, app_specs, target_definition.platform, build_type)
               hash[root_spec] ||= {}
               (hash[root_spec][pod_variant] ||= []) << target_definition
               pod_variant_spec = hash[root_spec].keys.find { |k| k == pod_variant }
@@ -616,13 +618,25 @@ module Pod
             end
           end
 
+          # Remap pod variants to a new instance that includes the Swift version since we now have the full set
+          # of target definitions.
+          distinct_targets = Hash[distinct_targets.map do |root, target_definitions_by_variant|
+            variants = Hash[target_definitions_by_variant.map do |variant, target_definitions|
+              swift_version = determine_swift_version(variant.root_spec, target_definitions)
+              [variant.scoped_with_swift_version(swift_version), target_definitions]
+            end]
+            [root, variants]
+          end]
+
           pod_targets = distinct_targets.flat_map do |_root, target_definitions_by_variant|
             target_definitions_by_variant.each_value do |target_definitions|
               target_definitions.reject!(&:abstract?) unless target_definitions.all?(&:abstract?)
             end
             suffixes = PodVariantSet.new(target_definitions_by_variant.keys).scope_suffixes
             target_definitions_by_variant.map do |variant, target_definitions|
-              generate_pod_target(target_definitions, target_inspections, variant.specs + variant.test_specs + variant.app_specs, :build_type => variant.build_type, :scope_suffix => suffixes[variant])
+              all_specs = variant.specs + variant.test_specs + variant.app_specs
+              generate_pod_target(target_definitions, variant.build_type, target_inspections, all_specs,
+                                  :scope_suffix => suffixes[variant], :swift_version => variant.swift_version)
             end
           end
 
@@ -633,8 +647,8 @@ module Pod
           resolver_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|
-              target_type = Target::BuildType.infer_from_spec(pod_specs.first, :host_requires_frameworks => target_definition.uses_frameworks?)
-              generate_pod_target([target_definition], target_inspections, pod_specs.map(&:spec), :build_type => target_type).scoped(dedupe_cache)
+              build_type = determine_build_type(pod_specs.first, target_definition.build_type)
+              generate_pod_target([target_definition], build_type, target_inspections, pod_specs.map(&:spec)).scoped(dedupe_cache)
             end
 
             compute_pod_target_dependencies(pod_targets, specs.map(&:spec).group_by(&:name))
@@ -660,23 +674,26 @@ module Pod
         end
 
         pod_targets.each do |target|
-          dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs).group_by(&:root)
-          target.dependent_targets = filter_dependencies(dependencies, pod_targets_by_name, target)
-          target.test_dependent_targets_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
-            test_dependencies = dependencies_for_specs([test_spec], target.platform, all_specs).group_by(&:root)
-            test_dependencies.delete_if { |k, _| dependencies.key? k }
-            hash[test_spec.name] = filter_dependencies(test_dependencies, pod_targets_by_name, target)
+          dependencies_by_config = dependencies_for_specs(target.library_specs, target.platform, all_specs)
+          target.dependent_targets_by_config = Hash[dependencies_by_config.map { |k, v| [k, filter_dependencies(v, pod_targets_by_name, target)] }]
+
+          target.test_dependent_targets_by_spec_name_by_config = target.test_specs.each_with_object({}) do |test_spec, hash|
+            test_dependencies_by_config = dependencies_for_specs([test_spec], target.platform, all_specs)
+            test_dependencies_by_config.each { |config, deps| deps.delete_if { |k, _| dependencies_by_config[config].key? k } }
+            hash[test_spec.name] = Hash[test_dependencies_by_config.map { |k, v| [k, filter_dependencies(v, pod_targets_by_name, target)] }]
           end
 
-          target.app_dependent_targets_by_spec_name = target.app_specs.each_with_object({}) do |app_spec, hash|
-            app_dependencies = dependencies_for_specs([app_spec], target.platform, all_specs).group_by(&:root)
-            app_dependencies.delete_if { |k, _| dependencies.key? k }
-            hash[app_spec.name] = filter_dependencies(app_dependencies, pod_targets_by_name, target)
+          target.app_dependent_targets_by_spec_name_by_config = target.app_specs.each_with_object({}) do |app_spec, hash|
+            app_dependencies_by_config = dependencies_for_specs([app_spec], target.platform, all_specs)
+            app_dependencies_by_config.each { |config, deps| deps.delete_if { |k, _| dependencies_by_config[config].key? k } }
+            hash[app_spec.name] = Hash[app_dependencies_by_config.map { |k, v| [k, filter_dependencies(v, pod_targets_by_name, target)] }]
           end
 
           target.test_app_hosts_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
             next unless app_host_name = test_spec.consumer(target.platform).app_host_name
-            app_host_spec = pod_targets_by_name[Specification.root_name(app_host_name)].flat_map(&:app_specs).find { |pt| pt.name == app_host_name }
+            app_host_spec = pod_targets_by_name[Specification.root_name(app_host_name)].flat_map(&:app_specs).find do |pt|
+              pt.name == app_host_name
+            end
             app_host_dependencies = { app_host_spec.root => [app_host_spec] }
             hash[test_spec.name] = [app_host_spec, filter_dependencies(app_host_dependencies, pod_targets_by_name, target).first]
           end
@@ -687,7 +704,7 @@ module Pod
         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.host_requires_frameworks? != target.host_requires_frameworks? # rather than target type or requires_frameworks? since we want to group by what was specified in that _target definition_
+                t.build_as_framework? != target.build_as_framework? # rather than target type or requires_frameworks? since we want to group by what was specified in that _target definition_
             spec_names = t.specs.map(&:name)
             deps.all? { |dep| spec_names.include?(dep.name) }
           end
@@ -705,38 +722,48 @@ module Pod
       # @param  [Platform] platform
       #         The platform for which the dependencies should be returned.
       #
-      # @param  [Hash<String, Specification>] all_specs
+      # @param  [Hash{String => Array<Specification>}] all_specs
       #         All specifications which are installed alongside.
       #
-      # @return [Array<Specification>]
+      # @return [Hash{Symbol => Set<Specification>}]
       #
       def dependencies_for_specs(specs, platform, all_specs)
-        return [] if specs.empty? || all_specs.empty?
-
-        dependent_specs = Set.new
+        dependent_specs = {
+          :debug => Set.new,
+          :release => Set.new,
+        }
+
+        if !specs.empty? && !all_specs.empty?
+          specs.each do |s|
+            s.dependencies(platform).each do |dep|
+              all_specs[dep.name].each do |spec|
+                if spec.non_library_specification?
+                  if s.test_specification? && spec.name == s.consumer(platform).app_host_name && spec.app_specification?
+                    # This needs to be handled separately, since we _don't_ want to treat this as a "normal" dependency
+                    next
+                  end
+                  raise Informative, "`#{s}` depends upon `#{spec}`, which is a `#{spec.spec_type}` spec."
+                end
 
-        specs.each do |s|
-          s.dependencies(platform).each do |dep|
-            all_specs[dep.name].each do |spec|
-              if spec.non_library_specification?
-                if s.test_specification? && spec.name == s.consumer(platform).app_host_name && spec.app_specification?
-                  # This needs to be handled separately, since we _don't_ want to treat this as a "normal" dependency
-                  next
+                dependent_specs.each do |config, set|
+                  next unless s.dependency_whitelisted_for_configuration?(dep, config)
+                  set << spec
                 end
-                raise Informative, "#{s} depends upon `#{spec}`, which is a `#{spec.spec_type}` spec."
               end
-              dependent_specs << spec
             end
           end
         end
 
-        dependent_specs - specs
+        Hash[dependent_specs.map { |k, v| [k, (v - specs).group_by(&:root)] }].freeze
       end
 
       # Create a target for each spec group
       #
       # @param  [Array<TargetDefinition>] target_definitions
-      #         the target definitions of the aggregate target
+      #         the target definitions of the pod target
+      #
+      # @param  [BuildType] build_type
+      #         the BuildType to use for this pod target.
       #
       # @param  [Hash{TargetDefinition => TargetInspectionResult}] target_inspections
       #         the user target inspections used to construct the aggregate and pod targets.
@@ -747,9 +774,13 @@ module Pod
       # @param  [String] scope_suffix
       #         @see PodTarget#scope_suffix
       #
+      # @param  [String] swift_version
+      #         @see PodTarget#swift_version
+      #
       # @return [PodTarget]
       #
-      def generate_pod_target(target_definitions, target_inspections, specs, scope_suffix: nil, build_type: nil)
+      def generate_pod_target(target_definitions, build_type, target_inspections, specs, scope_suffix: nil,
+                              swift_version: nil)
         target_inspections = target_inspections.select { |t, _| target_definitions.include?(t) }.values
         object_version = target_inspections.map { |ti| ti.project.object_version }.min
         target_requires_64_bit = target_definitions.all? { |td| Analyzer.requires_64_bit_archs?(td.platform, object_version) }
@@ -761,14 +792,15 @@ module Pod
                     target_inspections.flat_map(&:archs).compact.uniq.sort
                   end
         else
-          user_build_configurations = Target::DEFAULT_BUILD_CONFIGURATIONS
+          user_build_configurations = Target::DEFAULT_BUILD_CONFIGURATIONS.merge(
+            target_definitions.map { |td| td.build_configurations || {} }.reduce({}, &:merge),
+          )
           archs = target_requires_64_bit ? ['$(ARCHS_STANDARD_64_BIT)'] : []
         end
-        host_requires_frameworks = target_definitions.any?(&:uses_frameworks?)
-        platform = determine_platform(specs, target_definitions, host_requires_frameworks)
+        platform = determine_platform(specs, target_definitions, build_type)
         file_accessors = create_file_accessors(specs, platform)
-        PodTarget.new(sandbox, host_requires_frameworks, user_build_configurations, archs, platform, specs,
-                      target_definitions, file_accessors, scope_suffix, :build_type => build_type)
+        PodTarget.new(sandbox, build_type, user_build_configurations, archs, platform, specs, target_definitions,
+                      file_accessors, scope_suffix, swift_version)
       end
 
       # Creates the file accessors for a given pod.
@@ -802,25 +834,71 @@ module Pod
       # @param [Array<TargetDefinition>] target_definitions
       #        the target definitions these specs are part of.
       #
-      # @param [Boolean] host_requires_frameworks
-      #        whether the platform is calculated for a target that needs to be packaged as a framework.
+      # @param [BuildType] build_type
+      #        the #BuildType used for calculating the platform.
       #
       # @return [Platform]
       #
-      def determine_platform(specs, target_definitions, host_requires_frameworks)
+      def determine_platform(specs, target_definitions, build_type)
         library_specs = specs.select(&:library_specification?)
         platform_name = target_definitions.first.platform.name
         default = Podfile::TargetDefinition::PLATFORM_DEFAULTS[platform_name]
         deployment_target = library_specs.map do |library_spec|
           Version.new(library_spec.deployment_target(platform_name) || default)
         end.max
-        if platform_name == :ios && host_requires_frameworks
+        if platform_name == :ios && build_type.framework?
           minimum = Version.new('8.0')
           deployment_target = [deployment_target, minimum].max
         end
         Platform.new(platform_name, deployment_target)
       end
 
+      # Determines the Swift version for the given spec within a list of target definitions. If the pod author has
+      # provided a set of Swift versions supported by their pod then the max Swift version is chosen, unless the target
+      # definitions specify explicit requirements for supported Swift versions. Otherwise the Swift version is derived
+      # by the target definitions that integrate this pod.
+      #
+      # @param [Specification] spec
+      #        the specs to inspect and determine what Swift version to use.
+      #
+      # @param [Array<TargetDefinition>] target_definitions
+      #        the target definitions the spec is part of.
+      #
+      # @return [String, nil] the computed Swift version or `nil` if the Swift version could not be determined.
+      #
+      def determine_swift_version(spec, target_definitions)
+        if spec.swift_versions.empty?
+          target_definitions.map(&:swift_version).compact.uniq.first
+        else
+          spec.swift_versions.sort.reverse_each.find do |swift_version|
+            target_definitions.all? do |td|
+              td.supports_swift_version?(swift_version)
+            end
+          end.to_s
+        end
+      end
+
+      # Calculates and returns the #BuildType to use for the given spec. If the spec specifies `static_framework` then
+      # it is honored as long as the host #BuildType also requires its pods to be integrated as frameworks.
+      #
+      # @param [Specification] spec
+      #        the spec to determine the #BuildType for.
+      #
+      # @param [BuildType] target_definition_build_type
+      #        The desired #BuildType by the target definition that integrates this target. If the pod target spec does
+      #        not specify explicitly a `static_framework` #BuildType then the one from the target definition is used.
+      #
+      # @return [BuildType]
+      #
+      def determine_build_type(spec, target_definition_build_type)
+        if target_definition_build_type.framework?
+          root_spec = spec.root
+          root_spec.static_framework ? BuildType.static_framework : target_definition_build_type
+        else
+          BuildType.static_library
+        end
+      end
+
       # Generates dependencies that require the specific version of the Pods
       # that haven't changed in the {Lockfile}.
       #

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

@@ -19,15 +19,13 @@ module Pod
         #
         attr_reader :platform
 
-        # @return [Target::BuildType] the build type of the target
+        # @return [BuildType] the build type of the target
         #
         attr_reader :build_type
 
-        # @return [Specification] the root specification
+        # @return [String] the Swift version of the target.
         #
-        def root_spec
-          specs.first.root
-        end
+        attr_reader :swift_version
 
         # Initialize a new instance from its attributes.
         #
@@ -35,26 +33,35 @@ module Pod
         # @param [Array<Specification>] test_specs @see #test_specs
         # @param [Array<Specification>] app_specs  @see #app_specs
         # @param [Platform] platform               @see #platform
-        # @param [Target::BuildType] build_type    @see #build_type
+        # @param [BuildType] build_type            @see #build_type
+        # @param [String] swift_version            @see #swift_version
         #
-        def initialize(specs, test_specs, app_specs, platform, build_type = Target::BuildType.static_library)
+        def initialize(specs, test_specs, app_specs, platform, build_type = BuildType.static_library,
+                       swift_version = nil)
           @specs = specs
           @test_specs = test_specs
           @app_specs = app_specs
           @platform = platform
           @build_type = build_type
-          @hash = [specs, platform, build_type].hash
+          @swift_version = swift_version
+          @hash = [specs, platform, build_type, swift_version].hash
+        end
+
+        # @return [Specification] the root specification
+        #
+        def root_spec
+          specs.first.root
         end
 
-        # @note Test specs are intentionally not included as part of the equality for pod variants since a
-        #       pod variant should not be affected by the number of test nor app specs included.
+        # @note Non library specs are intentionally not included as part of the equality for pod variants since a pod
+        #       variant should not be affected by the number of test nor app specs included.
         #
-        # @return [Bool] whether the {PodVariant} is equal to another taking all
-        #         all their attributes into account
+        # @return [Bool] whether the {PodVariant} is equal to another taking all all their attributes into account
         #
         def ==(other)
           self.class == other.class &&
           build_type == other.build_type &&
+            swift_version == other.swift_version &&
             platform == other.platform &&
             specs == other.specs
         end
@@ -66,6 +73,14 @@ module Pod
         #
         # @!visibility private
         attr_reader :hash
+
+        # @param [String] swift_version The swift version to use for this variant.
+        #
+        # @return [PodVariant] A copy of this pod variant with the specified Swift version.
+        #
+        def scoped_with_swift_version(swift_version)
+          PodVariant.new(specs, test_specs, app_specs, platform, build_type, swift_version)
+        end
       end
     end
   end

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

@@ -98,7 +98,16 @@ module Pod
             # => 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)
+          scope_if_necessary(grouped_variants.map(&:scope_by_swift_version), &platform_name_proc)
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_swift_version
+          scope_if_necessary(group_by(&:swift_version).map(&:scope_without_suffix)) do |variant|
+            variant.swift_version ? "Swift#{variant.swift_version}" : ''
+          end
         end
 
         # @private
@@ -113,7 +122,7 @@ module Pod
                      root_spec.default_subspecs.map do |subspec_name|
                        root_spec.subspec_by_name("#{root_spec.name}/#{subspec_name}")
                      end
-          end
+                   end
           default_specs = Set.new(specs)
           grouped_variants = group_by(&:specs)
           all_spec_variants = grouped_variants.map { |set| set.variants.first.specs }