cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/installer/analyzer.rb

@@ -1,3 +1,5 @@
+require 'cocoapods/podfile'
+
 module Pod
   class Installer
     # Analyzes the Podfile, the Lockfile, and the sandbox manifest to generate
@@ -5,9 +7,6 @@ module Pod
     #
     class Analyzer
       include Config::Mixin
-      include InstallationOptions::Mixin
-
-      delegate_installation_options { podfile }
 
       autoload :AnalysisResult,            'cocoapods/installer/analyzer/analysis_result'
       autoload :LockingDependencyAnalyzer, 'cocoapods/installer/analyzer/locking_dependency_analyzer'
@@ -56,6 +55,10 @@ module Pod
       #
       attr_reader :pods_to_update
 
+      # @return [InstallationOptions] the installation options specified by the Podfile
+      #
+      attr_reader :installation_options
+
       # Initialize a new instance
       #
       # @param  [Sandbox] sandbox @see #sandbox
@@ -73,6 +76,7 @@ module Pod
         @plugin_sources = plugin_sources
         @has_dependencies = has_dependencies
         @pods_to_update = pods_to_update
+        @installation_options = podfile.installation_options
         @podfile_dependency_cache = PodfileDependencyCache.from_podfile(podfile)
         @result = nil
       end
@@ -114,7 +118,7 @@ module Pod
         resolver_specs_by_target = resolve_dependencies(locked_dependencies)
         validate_platforms(resolver_specs_by_target)
         specifications  = generate_specifications(resolver_specs_by_target)
-        targets         = generate_targets(resolver_specs_by_target, target_inspections)
+        targets         = generate_aggregate_targets(resolver_specs_by_target, target_inspections)
         pod_targets     = calculate_pod_targets(targets)
         sandbox_state   = generate_sandbox_state(specifications)
         specs_by_target = resolver_specs_by_target.each_with_object({}) do |rspecs_by_target, hash|
@@ -160,7 +164,7 @@ module Pod
           if all_dependencies_have_sources
             sources = dependency_sources
           elsif has_dependencies? && sources.empty? && plugin_sources.empty?
-            sources = ['https://github.com/CocoaPods/Specs.git']
+            sources = ['https://github.com/CocoaPods/Specs.git'] + dependency_sources
           else
             sources += dependency_sources
           end
@@ -303,7 +307,7 @@ module Pod
                 pod_target.name
               end
             end
-            embedded_pod_targets_by_build_config[configuration_name] += embedded_pod_targets
+            embedded_pod_targets_by_build_config[configuration_name] = embedded_pod_targets
           end
         end
         embedded_pod_targets_by_build_config
@@ -401,11 +405,11 @@ module Pod
       #
       # @return [Array<AggregateTarget>] the list of aggregate targets generated.
       #
-      def generate_targets(resolver_specs_by_target, target_inspections)
+      def generate_aggregate_targets(resolver_specs_by_target, target_inspections)
         resolver_specs_by_target = resolver_specs_by_target.reject { |td, _| td.abstract? }
         pod_targets = generate_pod_targets(resolver_specs_by_target, target_inspections)
         aggregate_targets = resolver_specs_by_target.keys.map do |target_definition|
-          generate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
+          generate_aggregate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
         end
         aggregate_targets.each do |target|
           search_paths_aggregate_targets = aggregate_targets.select do |aggregate_target|
@@ -419,13 +423,13 @@ 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(&:requires_frameworks?)
+          use_frameworks_embedded_targets, non_use_frameworks_embedded_targets = embedded_targets.partition(&:host_requires_frameworks?)
           aggregate_targets = aggregate_targets.map do |aggregate_target|
-            # For targets that require frameworks, we always have to copy their pods to their
+            # 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
             embedded_pod_targets = embedded_target_pod_targets_by_host(aggregate_target, use_frameworks_embedded_targets, false)
 
-            # For targets that don't require frameworks, we only have to consider library-type
+            # For targets that don't require dynamic frameworks, we only have to consider library-type
             # targets because their host targets will still need to link their pods
             embedded_pod_targets.merge!(embedded_target_pod_targets_by_host(aggregate_target, non_use_frameworks_embedded_targets, true))
 
@@ -452,7 +456,7 @@ module Pod
       #
       # @return [AggregateTarget]
       #
-      def generate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
+      def generate_aggregate_target(target_definition, target_inspections, pod_targets, resolver_specs_by_target)
         if installation_options.integrate_targets?
           target_inspection = target_inspections[target_definition]
           raise "missing inspection: #{target_definition.name}" unless target_inspection
@@ -475,9 +479,11 @@ module Pod
         pod_targets_for_build_configuration = filter_pod_targets_for_target_definition(target_definition, pod_targets,
                                                                                        resolver_specs_by_target,
                                                                                        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)
+                            pod_targets_for_build_configuration, :build_type => build_type)
       end
 
       # @return [Array<PodTarget>] The model representations of pod targets.
@@ -489,7 +495,12 @@ module Pod
             pod_target.recursive_test_dependent_targets(test_spec)
           end
         end
-        (aggregate_target_pod_targets + test_dependent_targets).uniq
+        app_dependent_targets = aggregate_target_pod_targets.flat_map do |pod_target|
+          pod_target.app_specs.flat_map do |app_spec|
+            pod_target.recursive_app_dependent_targets(app_spec)
+          end
+        end
+        (aggregate_target_pod_targets + test_dependent_targets + app_dependent_targets).uniq
       end
 
       # Returns a filtered list of pod targets that should or should not be part of the target definition. Pod targets
@@ -517,7 +528,7 @@ module Pod
         pod_targets.each do |pod_target|
           next unless pod_target.target_definitions.include?(target_definition)
           next unless resolver_specs_by_target[target_definition].any? do |resolver_spec|
-            !resolver_spec.used_by_tests_only? && pod_target.specs.include?(resolver_spec.spec)
+            !resolver_spec.used_by_non_library_targets_only? && pod_target.specs.include?(resolver_spec.spec)
           end
 
           pod_name = pod_target.pod_name
@@ -566,54 +577,71 @@ module Pod
             target_definition, dependent_specs = *dependency
             dependent_specs.group_by(&:root).each do |root_spec, resolver_specs|
               all_specs = resolver_specs.map(&:spec)
-              test_specs, specs = all_specs.partition(&:test_specification?)
-              pod_variant = PodVariant.new(specs, test_specs, target_definition.platform, target_definition.uses_frameworks?)
+              all_specs_by_type = all_specs.group_by(&:spec_type)
+              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)
               hash[root_spec] ||= {}
               (hash[root_spec][pod_variant] ||= []) << target_definition
-              hash[root_spec].keys.find { |k| k == pod_variant }.test_specs.concat(test_specs).uniq!
+              pod_variant_spec = hash[root_spec].keys.find { |k| k == pod_variant }
+              pod_variant_spec.test_specs.concat(test_specs).uniq!
+              pod_variant_spec.app_specs.concat(app_specs).uniq!
             end
           end
 
           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, target_inspections, variant.specs + variant.test_specs, :scope_suffix => suffixes[variant])
+            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])
             end
           end
 
-          all_resolver_specs = resolver_specs_by_target.values.flatten.map(&:spec).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
+          all_specs = resolver_specs_by_target.values.flatten.map(&:spec).uniq.group_by(&:name)
           pod_targets.each do |target|
-            all_specs = all_resolver_specs.group_by(&:name)
-            dependencies = dependencies_for_specs(target.non_test_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
+            dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs.dup).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)
             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)
+            end
           end
         else
           dedupe_cache = {}
           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|
-              generate_pod_target([target_definition], target_inspections, pod_specs.map(&:spec)).scoped(dedupe_cache)
+              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)
             end
 
             pod_targets.each do |target|
               all_specs = specs.map(&:spec).group_by(&:name)
-              dependencies = dependencies_for_specs(target.non_test_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
+              dependencies = dependencies_for_specs(target.library_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
               target.dependent_targets = pod_targets.reject { |t| dependencies[t.root_spec].nil? }
               target.test_dependent_targets_by_spec_name = target.test_specs.each_with_object({}) do |test_spec, hash|
                 test_dependencies = dependencies_for_specs(target.test_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
                 test_dependencies.delete_if { |k| dependencies.key? k }
                 hash[test_spec.name] = pod_targets.reject { |t| test_dependencies[t.root_spec].nil? }
               end
+              target.app_dependent_targets_by_spec_name = target.app_specs.each_with_object({}) do |app_spec, hash|
+                app_dependencies = dependencies_for_specs(target.app_specs.to_set, target.platform, all_specs.dup).group_by(&:root)
+                app_dependencies.delete_if { |k| dependencies.key? k }
+                hash[app_spec.name] = pod_targets.reject { |t| app_dependencies[t.root_spec].nil? }
+              end
             end
           end
         end
@@ -623,7 +651,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.requires_frameworks? != target.requires_frameworks?
+                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_
             spec_names = t.specs.map(&:name)
             deps.all? { |dep| spec_names.include?(dep.name) }
           end
@@ -678,7 +706,7 @@ module Pod
       #
       # @return [PodTarget]
       #
-      def generate_pod_target(target_definitions, target_inspections, specs, scope_suffix: nil)
+      def generate_pod_target(target_definitions, target_inspections, specs, scope_suffix: nil, build_type: nil)
         object_version = target_inspections.values.map { |ti| ti.project.object_version }.min
         target_requires_64_bit = target_definitions.all? { |td| Analyzer.requires_64_bit_archs?(td.platform, object_version) }
         if installation_options.integrate_targets?
@@ -697,7 +725,7 @@ module Pod
         platform = determine_platform(specs, target_definitions, host_requires_frameworks)
         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)
+                      target_definitions, file_accessors, scope_suffix, :build_type => build_type)
       end
 
       # Creates the file accessors for a given pod.
@@ -869,8 +897,9 @@ module Pod
       end
 
       def store_existing_checkout_options
+        return unless lockfile
         podfile_dependencies.select(&:external_source).each do |dep|
-          if checkout_options = lockfile && lockfile.checkout_options_for_pod_named(dep.root_name)
+          if checkout_options = lockfile.checkout_options_for_pod_named(dep.root_name)
             sandbox.store_checkout_source(dep.root_name, checkout_options)
           end
         end
@@ -914,12 +943,9 @@ module Pod
 
       # Warns for any specification that is incompatible with its target.
       #
-      # @param  [Hash{TargetDefinition => Array<Spec>}] resolver_specs_by_target
+      # @param  [Hash{TargetDefinition => Array<Specification>}] resolver_specs_by_target
       #         the resolved specifications grouped by target.
       #
-      # @return [Hash{TargetDefinition => Array<Spec>}] the specifications
-      #         grouped by target.
-      #
       def validate_platforms(resolver_specs_by_target)
         resolver_specs_by_target.each do |target, specs|
           specs.map(&:spec).each do |spec|
@@ -935,7 +961,7 @@ module Pod
 
       # Returns the list of all the resolved specifications.
       #
-      # @param  [Hash{TargetDefinition => Array<Spec>}] resolver_specs_by_target
+      # @param  [Hash{TargetDefinition => Array<Specification>}] resolver_specs_by_target
       #         the resolved specifications grouped by target.
       #
       # @return [Array<Specification>] the list of the specifications.
@@ -997,11 +1023,10 @@ module Pod
       # @return [void]
       #
       def verify_platforms_specified!
-        unless installation_options.integrate_targets?
-          @podfile_dependency_cache.target_definition_list.each do |target_definition|
-            if !target_definition.empty? && target_definition.platform.nil?
-              raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
-            end
+        return if installation_options.integrate_targets?
+        @podfile_dependency_cache.target_definition_list.each do |target_definition|
+          if !target_definition.empty? && target_definition.platform.nil?
+            raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
           end
         end
       end

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

@@ -11,14 +11,17 @@ module Pod
         #
         attr_reader :test_specs
 
+        # @return [Array<Specification>] the app specs for the target
+        #
+        attr_reader :app_specs
+
         # @return [Platform] the platform
         #
         attr_reader :platform
 
-        # @return [Bool] whether this pod should be built as framework
+        # @return [Target::BuildType] the build type of the target
         #
-        attr_reader :requires_frameworks
-        alias_method :requires_frameworks?, :requires_frameworks
+        attr_reader :build_type
 
         # @return [Specification] the root specification
         #
@@ -30,26 +33,28 @@ module Pod
         #
         # @param [Array<Specification>] specs      @see #specs
         # @param [Array<Specification>] test_specs @see #test_specs
+        # @param [Array<Specification>] app_specs  @see #app_specs
         # @param [Platform] platform               @see #platform
-        # @param [Bool] requires_frameworks        @see #requires_frameworks?
+        # @param [Target::BuildType] build_type    @see #build_type
         #
-        def initialize(specs, test_specs, platform, requires_frameworks = false)
+        def initialize(specs, test_specs, app_specs, platform, build_type = Target::BuildType.static_library)
           @specs = specs
           @test_specs = test_specs
+          @app_specs = app_specs
           @platform = platform
-          @requires_frameworks = requires_frameworks
-          @hash = [specs, platform, requires_frameworks].hash
+          @build_type = build_type
+          @hash = [specs, platform, build_type].hash
         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 specs included.
+        #       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
         #
         def ==(other)
           self.class == other.class &&
-            requires_frameworks == other.requires_frameworks &&
+          build_type == other.build_type &&
             platform == other.platform &&
             specs == other.specs
         end

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

@@ -71,8 +71,17 @@ module Pod
         # @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'
+          scope_if_necessary(group_by { |v| v.build_type.packaging }.map(&:scope_by_linkage)) do |variant|
+            variant.build_type.packaging
+          end
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_linkage
+          scope_if_necessary(group_by { |v| v.build_type.linkage }.map(&:scope_by_platform)) do |variant|
+            variant.build_type.linkage
           end
         end
 

data/lib/cocoapods/installer/installation_options.rb

@@ -38,7 +38,7 @@ module Pod
       #
       #   @note this option defaults to $2.
       #
-      #   @return the $1 $0 for installation.
+      #   @return [Boolean] the $1 $0 for installation.
       #
       def self.option(name, default, boolean: true)
         name = name.to_s
@@ -101,60 +101,86 @@ module Pod
         to_h.hash
       end
 
+      # Whether to clean the sources of the pods during installation
+      #
+      # Cleaning removes any files not used by the pod as specified by the podspec and the platforms
+      # that the project supports
+      #
+      # @see {PodSourceInstaller#clean!}
+      #
       option :clean, true
+
+      # Whether to deduplicate pod targets
+      #
+      # Target deduplication adds suffixes to pod targets for the cases where a pod is included
+      # in multiple targets that have different requirements. For example, a pod named 'MyPod' with a subspec 'SubA'
+      # that is included in two targets as follows:
+      #
+      #     target 'MyTargetA' do
+      #       pod 'MyPod/SubA'
+      #     end
+      #
+      #     target 'MyTargetB' do
+      #       pod 'MyPod'
+      #     end
+      #
+      # will result in two Pod targets: `MyPod` and `MyPod-SubA`
+      #
       option :deduplicate_targets, true
+
+      # Whether to generate deterministic UUIDs when creating the Pods project
+      #
+      # @see {Xcodeproj#generate_uuid}
+      #
       option :deterministic_uuids, true
+
+      # Whether to integrate the installed pods into the user project
+      #
+      # If set to false, Pods will be downloaded and installed to the `Pods/` directory
+      # but they will not be integrated into your project.
+      #
       option :integrate_targets, true
+
+      # Whether to lock the source files of pods. Xcode will prompt to unlock the files when attempting to modify
+      # their contents
+      #
+      # @note There is a performance penalty to locking the pods during installation. If this is significantly
+      #       impacting the duration of `pod install` for your project, you can try setting this to `false`
+      #
       option :lock_pod_sources, true
+
+      # Whether to emit a warning when multiple sources contain a Pod with the same name and version
+      #
       option :warn_for_multiple_pod_sources, true
+
+      # Whether to share Xcode schemes for development pods.
+      #
+      # Schemes for development pods are created automatically but are not shared by default.
+      #
       option :share_schemes_for_development_pods, false
+
+      # Whether to disable the input & output paths of the CocoaPods script phases (Copy Frameworks & Copy Resources)
+      #
+      # @see https://github.com/CocoaPods/CocoaPods/issues/8073
+      #
       option :disable_input_output_paths, false
-      option :preserve_pod_file_structure, false
 
-      module Mixin
-        module ClassMethods
-          # Delegates the creation of {#installation_options} to the `Podfile`
-          # returned by the given block.
-          #
-          # @param  blk a block that returns the `Podfile` to create
-          #         installation options from.
-          #
-          # @return [Void]
-          #
-          def delegate_installation_options(&blk)
-            define_method(:installation_options) do
-              @installation_options ||= InstallationOptions.from_podfile(instance_eval(&blk))
-            end
-          end
-
-          # Delegates the installation options attributes directly to
-          # {#installation_options}.
-          #
-          # @return [Void]
-          #
-          def delegate_installation_option_attributes!
-            define_method(:respond_to_missing?) do |name, *args|
-              installation_options.respond_to?(name, *args) || super
-            end
-
-            define_method(:method_missing) do |name, *args, &blk|
-              if installation_options.respond_to?(name)
-                installation_options.send(name, *args, &blk)
-              else
-                super
-              end
-            end
-          end
-        end
+      # Whether to preserve the file structure of all Pods, including externally sourced pods.
+      #
+      # By default, the file structure of Pod sources is preserved only for development pods. Setting
+      # `:preserve_pod_file_structure` to `true` will _always_ preserve the file structure.
+      #
+      option :preserve_pod_file_structure, false
 
-        # @return [InstallationOptions] The installation options.
-        #
-        attr_accessor :installation_options
+      # Whether to generate a project per pod target. Instead of creating 1 `Pods.xcodeproj`, this option will generate
+      # a project for every pod target that will be nested under the `Pods.xcodeproj`.
+      #
+      option :generate_multiple_pod_projects, false
 
-        def self.included(mod)
-          mod.extend(ClassMethods)
-        end
-      end
+      # Whether to enable only regenerating targets and their associate projects that have changed
+      # since the previous installation.
+      #
+      option :incremental_installation, false
     end
   end
 end