cocoapods 1.6.2 → 1.7.0.beta.1

data/lib/cocoapods/installer/xcode/pods_project_generator/target_installer.rb

@@ -17,7 +17,7 @@ module Pod
           attr_reader :sandbox
 
           # @return [Pod::Project]
-          #         The `Pods/Pods.xcodeproj` to install the target into.
+          #         The project to install the target into.
           #
           attr_reader :project
 
@@ -91,11 +91,9 @@ module Pod
               settings['ARCHS'] = target.archs
             end
 
-            if target.requires_frameworks?
-              if target.static_framework?
-                settings['MACH_O_TYPE'] = 'staticlib'
-              end
-            else
+            if target.build_as_static_framework?
+              settings['MACH_O_TYPE'] = 'staticlib'
+            elsif target.build_as_static_library?
               settings.merge!('OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '')
             end
 
@@ -204,7 +202,7 @@ module Pod
                 FileUtils.ln_sf(source, linked_path)
               end
 
-              acl = target.requires_frameworks? ? 'Public' : 'Project'
+              acl = target.build_as_framework? ? 'Public' : 'Project'
               build_file.settings ||= {}
               build_file.settings['ATTRIBUTES'] = [acl]
             end

data/lib/cocoapods/installer/xcode/pods_project_generator/target_installer_helper.rb

@@ -63,8 +63,40 @@ module Pod
             end
           end
 
+          # Creates a prefix header file which imports `UIKit` or `Cocoa` according
+          # to the platform of the target. This file also include any prefix header
+          # content reported by the specification of the pods.
+          #
+          # @param [Pathname] path
+          #        the path to generate the prefix header for.
+          #
+          # @param [Array<Sandbox::FileAccessor>] file_accessors
+          #        the file accessors to use for this prefix header that point to a path of a prefix header.
+          #
+          # @param [Platform] platform
+          #        the platform to use for this prefix header.
+          #
+          # @param [PBXNativeTarget] native_target
+          #        the native target on which the prefix header should be configured for.
+          #
+          # @param [Pathname] project_directory
+          #        the directory containing the project of the target
+          #
+          # @return [void]
+          #
+          def create_prefix_header(path, file_accessors, platform, native_target, project_directory)
+            generator = Generator::PrefixHeader.new(file_accessors, platform)
+            update_changed_file(generator, path)
+
+            relative_path = path.relative_path_from(project_directory).to_s
+            native_target.build_configurations.each do |c|
+              c.build_settings['GCC_PREFIX_HEADER'] = relative_path
+            end
+          end
+
           module_function :update_changed_file
           module_function :create_info_plist_file_with_sandbox
+          module_function :create_prefix_header
         end
       end
     end

data/lib/cocoapods/installer/xcode/pods_project_generator_result.rb

@@ -0,0 +1,35 @@
+module Pod
+  class Installer
+    class Xcode
+      class PodsProjectGenerator
+        # A simple container produced after a pod project generation is completed.
+        #
+        class PodsProjectGeneratorResult
+          # @return [Project] project
+          #
+          attr_reader :project
+
+          # @return [Hash{Project => Array<PodTargets>}] Project by pod targets map
+          #
+          attr_reader :projects_by_pod_targets
+
+          # @return [InstallationResults] target installation results
+          #
+          attr_reader :target_installation_results
+
+          # Initialize a new instance
+          #
+          # @param [Project] project @see #project
+          # @param [Hash{Project => Array<PodTargets>}] projects_by_pod_targets @see #projects_by_pod_targets
+          # @param [InstallationResults] target_installation_results @see #target_installation_results
+          #
+          def initialize(project, projects_by_pod_targets, target_installation_results)
+            @project = project
+            @projects_by_pod_targets = projects_by_pod_targets
+            @target_installation_results = target_installation_results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/xcode/single_pods_project_generator.rb

@@ -0,0 +1,38 @@
+module Pod
+  class Installer
+    class Xcode
+      # The {SinglePodsProjectGenerator} handles generation of the 'Pods/Pods.xcodeproj'
+      #
+      class SinglePodsProjectGenerator < PodsProjectGenerator
+        # Generates single `Pods/Pods.xcodeproj`.
+        #
+        # @return [PodsProjectGeneratorResult]
+        #
+        def generate!
+          project_path = sandbox.project_path
+          platforms = aggregate_targets.map(&:platform)
+          project_generator = ProjectGenerator.new(sandbox, project_path, pod_targets, build_configurations,
+                                                   platforms, project_object_version, config.podfile_path)
+          project = project_generator.generate!
+          install_file_references(project, pod_targets)
+
+          pod_target_installation_results = install_all_pod_targets(project, pod_targets)
+          aggregate_target_installation_results = install_aggregate_targets(project, aggregate_targets)
+          target_installation_results = InstallationResults.new(pod_target_installation_results, aggregate_target_installation_results)
+
+          integrate_targets(target_installation_results.pod_target_installation_results)
+          wire_target_dependencies(target_installation_results)
+          PodsProjectGeneratorResult.new(project, {}, target_installation_results)
+        end
+
+        private
+
+        def install_all_pod_targets(project, pod_targets)
+          UI.message '- Installing Pod Targets' do
+            install_pod_targets(project, pod_targets)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/xcode/target_validator.rb

@@ -47,11 +47,11 @@ module Pod
               file_accessors = pod_targets.flat_map(&:file_accessors)
 
               frameworks = file_accessors.flat_map(&:vendored_frameworks).uniq.map(&:basename)
-              frameworks += pod_targets.select { |pt| pt.should_build? && pt.requires_frameworks? }.map(&:product_module_name).uniq
+              frameworks += pod_targets.select { |pt| pt.should_build? && pt.build_as_framework? }.map(&:product_module_name).uniq
               verify_no_duplicate_names(frameworks, aggregate_target.label, 'frameworks')
 
               libraries = file_accessors.flat_map(&:vendored_libraries).uniq.map(&:basename)
-              libraries += pod_targets.select { |pt| pt.should_build? && !pt.requires_frameworks? }.map(&:product_name)
+              libraries += pod_targets.select { |pt| pt.should_build? && pt.build_as_library? }.map(&:product_name)
               verify_no_duplicate_names(libraries, aggregate_target.label, 'libraries')
             end
           end
@@ -68,24 +68,24 @@ module Pod
 
         def verify_no_static_framework_transitive_dependencies
           aggregate_targets.each do |aggregate_target|
-            next unless aggregate_target.requires_frameworks?
-
-            aggregate_target.user_build_configurations.keys.each do |config|
-              dynamic_pod_targets = aggregate_target.pod_targets_for_build_configuration(config).reject(&:static_framework?)
+            aggregate_target.user_build_configurations.each_key do |config|
+              pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
+              built_targets, unbuilt_targets = pod_targets.partition(&:should_build?)
+              dynamic_pod_targets = built_targets.select(&:build_as_dynamic?)
 
-              dependencies = dynamic_pod_targets.select(&:should_build?).flat_map(&:dependencies)
-              depended_upon_targets = dynamic_pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
+              dependencies = dynamic_pod_targets.flat_map(&:dependencies)
+              depended_upon_targets = unbuilt_targets.select { |t| dependencies.include?(t.pod_name) }
 
               static_libs = depended_upon_targets.flat_map(&:file_accessors).flat_map(&:vendored_static_artifacts)
               unless static_libs.empty?
                 raise Informative, "The '#{aggregate_target.label}' target has " \
-                  "transitive dependencies that include static binaries: (#{static_libs.to_sentence})"
+                  "transitive dependencies that include statically linked binaries: (#{static_libs.to_sentence})"
               end
 
-              static_framework_deps = dynamic_pod_targets.select(&:should_build?).flat_map(&:recursive_dependent_targets).select(&:static_framework?)
-              unless static_framework_deps.empty?
+              static_deps = dynamic_pod_targets.flat_map(&:recursive_dependent_targets).select(&:build_as_static?).uniq
+              unless static_deps.empty?
                 raise Informative, "The '#{aggregate_target.label}' target has " \
-                  "transitive dependencies that include static frameworks: (#{static_framework_deps.flat_map(&:name).to_sentence})"
+                  "transitive dependencies that include statically linked binaries: (#{static_deps.flat_map(&:name).to_sentence})"
               end
             end
           end
@@ -96,18 +96,25 @@ module Pod
             "`#{target_definition.name}` (Swift #{target_definition.swift_version})"
           end
           swift_pod_targets = pod_targets.select(&:uses_swift?)
-          error_messages = swift_pod_targets.map do |pod_target|
-            next unless pod_target.spec_swift_version.nil?
-            swift_target_definitions = pod_target.target_definitions.reject { |target| target.swift_version.blank? }
-            next if swift_target_definitions.uniq(&:swift_version).count == 1
-            if swift_target_definitions.empty?
-              "- `#{pod_target.name}` does not specify a Swift version and none of the targets " \
-                "(#{pod_target.target_definitions.map { |td| "`#{td.name}`" }.to_sentence}) integrating it have the " \
-                '`SWIFT_VERSION` attribute set. Please contact the author or set the `SWIFT_VERSION` attribute in at ' \
-                'least one of the targets that integrate this pod.'
-            else
-              target_errors = swift_target_definitions.map(&error_message_for_target_definition).to_sentence
-              "- `#{pod_target.name}` is integrated by multiple targets that use a different Swift version: #{target_errors}."
+          error_messages = swift_pod_targets.map do |swift_pod_target|
+            # Legacy targets that do not specify Swift versions derive their Swift version from the target definitions
+            # they are integrated with. An error is displayed if the target definition Swift versions collide or none
+            # of target definitions specify the `SWIFT_VERSION` attribute.
+            if swift_pod_target.spec_swift_versions.empty?
+              swift_target_definitions = swift_pod_target.target_definitions.reject { |target| target.swift_version.blank? }
+              next if swift_target_definitions.uniq(&:swift_version).count == 1
+              if swift_target_definitions.empty?
+                "- `#{swift_pod_target.name}` does not specify a Swift version and none of the targets " \
+                  "(#{swift_pod_target.target_definitions.map { |td| "`#{td.name}`" }.to_sentence}) integrating it have the " \
+                  '`SWIFT_VERSION` attribute set. Please contact the author or set the `SWIFT_VERSION` attribute in at ' \
+                  'least one of the targets that integrate this pod.'
+              else
+                target_errors = swift_target_definitions.map(&error_message_for_target_definition).to_sentence
+                "- `#{swift_pod_target.name}` is integrated by multiple targets that use a different Swift version: #{target_errors}."
+              end
+            elsif swift_pod_target.swift_version.empty?
+              "- `#{swift_pod_target.name}` does not specify a Swift version (#{swift_pod_target.spec_swift_versions.map { |v| "`#{v}`" }.to_sentence}) " \
+                "that is satisfied by any of targets (#{swift_pod_target.target_definitions.map { |td| "`#{td.name}`" }.to_sentence}) integrating it."
             end
           end.compact
 
@@ -130,7 +137,7 @@ module Pod
             next if non_module_dependencies.empty?
 
             error_messages << "The Swift pod `#{pod_target.name}` depends upon #{non_module_dependencies.map { |d| "`#{d}`" }.to_sentence}, " \
-                              'which do not define modules. ' \
+                              "which #{non_module_dependencies.count == 1 ? 'does' : 'do'} not define modules. " \
                               'To opt into those targets generating module maps '\
                               '(which is necessary to import them from Swift when building as static libraries), ' \
                               'you may set `use_modular_headers!` globally in your Podfile, '\

data/lib/cocoapods/native_target_extension.rb

@@ -0,0 +1,54 @@
+module Pod
+  class Project
+    # Adds a dependency on the given metadata cache.
+    #
+    # @param  [AbstractTarget] target
+    #         The parent target used to add a cached dependency.
+    #
+    # @param  [MetadataCache] metadata
+    #         The metadata holding all the required metadata to construct a target as a dependency.
+    #
+    # @return [void]
+    #
+    def self.add_cached_dependency(target, metadata)
+      return if dependency_for_cached_target?(target, metadata)
+      container_proxy = target.project.new(Xcodeproj::Project::PBXContainerItemProxy)
+
+      subproject_reference = target.project.reference_for_path(metadata.container_project_path)
+      raise ArgumentError, "add_dependency received target (#{target}) that belongs to a project that is not this project (#{self}) and is not a subproject of this project" unless subproject_reference
+      container_proxy.container_portal = subproject_reference.uuid
+
+      container_proxy.proxy_type = Xcodeproj::Constants::PROXY_TYPES[:native_target]
+      container_proxy.remote_global_id_string = metadata.native_target_uuid
+      container_proxy.remote_info = metadata.target_label
+
+      dependency = target.project.new(Xcodeproj::Project::PBXTargetDependency)
+      dependency.name = metadata.target_label
+      dependency.target_proxy = container_proxy
+
+      target.dependencies << dependency
+    end
+
+    # Checks whether this target has a dependency on the given target.
+    #
+    # @param  [AbstractTarget] target
+    #         The parent target used to add a cached dependency.
+    #
+    # @param  [TargetMetadata] cached_target
+    #         the target to search for.
+    #
+    # @return [Bool]
+    #
+    def self.dependency_for_cached_target?(target, cached_target)
+      target.dependencies.find do |dep|
+        if dep.target_proxy.remote?
+          subproject_reference = target.project.reference_for_path(cached_target.container_project_path)
+          uuid = subproject_reference.uuid if subproject_reference
+          dep.target_proxy.remote_global_id_string == cached_target.native_target_uuid && dep.target_proxy.container_portal == uuid
+        else
+          dep.target.uuid == cached_target.native_target_uuid
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/open-uri.rb

@@ -8,7 +8,7 @@ module OpenURI
   # Whether {#open} should follow a redirect.
   #
   # Inspiration from: https://gist.github.com/1271420
-  # Relevant issue:   http://redmine.ruby-lang.org/issues/3719
+  # Relevant issue:   https://bugs.ruby-lang.org/issues/3719
   # Source here:      https://github.com/ruby/ruby/blob/trunk/lib/open-uri.rb
   #
   # This test is intended to forbid a redirection from http://... to

data/lib/cocoapods/podfile.rb

@@ -0,0 +1,13 @@
+require 'cocoapods-core/podfile'
+
+module Pod
+  class Podfile
+    autoload :InstallationOptions, 'cocoapods/installer/installation_options'
+
+    # @return [Pod::Installer::InstallationOptions] the installation options specified in the Podfile
+    #
+    def installation_options
+      @installation_options ||= Pod::Installer::InstallationOptions.from_podfile(self)
+    end
+  end
+end

data/lib/cocoapods/project.rb

@@ -21,22 +21,39 @@ module Pod
     #
     attr_reader :development_pods
 
+    # @return [PBXGroup] The group for dependencies.
+    # Used by #generate_multiple_pod_projects installation option.
+    #
+    attr_reader :dependencies_group
+
+    # @return [Bool] Bool indicating if this project is a pod target subproject.
+    # Used by `generate_multiple_pod_projects` installation option.
+    #
+    attr_reader :pod_target_subproject
+    alias pod_target_subproject? pod_target_subproject
+
+    # @return [String] The basename of the project path without .xcodeproj extension.
+    #
+    attr_reader :project_name
+
     # Initialize a new instance
     #
-    # @param  [Pathname, String] path @see #path
-    # @param  [Bool] skip_initialization
-    #         Whether the project should be initialized from scratch.
-    # @param  [Int] object_version
-    #         Object version to use for serialization, defaults to Xcode 3.2 compatible.
+    # @param  [Pathname, String] path @see Xcodeproj::Project#path
+    # @param  [Bool] skip_initialization Whether the project should be initialized from scratch.
+    # @param  [Int] object_version Object version to use for serialization, defaults to Xcode 3.2 compatible.
     #
     def initialize(path, skip_initialization = false,
-        object_version = Xcodeproj::Constants::DEFAULT_OBJECT_VERSION)
+                    object_version = Xcodeproj::Constants::DEFAULT_OBJECT_VERSION, pod_target_subproject: false)
+      @uuid_prefix = Digest('SHA256').hexdigest(File.basename(path)).upcase
       super(path, skip_initialization, object_version)
       @support_files_group = new_group('Targets Support Files')
       @refs_by_absolute_path = {}
       @variant_groups_by_path_and_name = {}
       @pods = new_group('Pods')
       @development_pods = new_group('Development Pods')
+      @dependencies_group = new_group('Dependencies')
+      @pod_target_subproject = pod_target_subproject
+      @project_name = Pathname(path).basename('.*')
       self.symroot = LEGACY_BUILD_ROOT
     end
 
@@ -52,7 +69,7 @@ module Pod
     #
     def generate_available_uuid_list(count = 100)
       start = @generated_uuids.size
-      uniques = Array.new(count) { |i| format('%011X0', start + i) }
+      uniques = Array.new(count) { |i| format('%.4s%07X0', @uuid_prefix, start + i) }
       @generated_uuids += uniques
       @available_uuids += uniques
     end
@@ -101,7 +118,12 @@ module Pod
     def add_pod_group(pod_name, path, development = false, absolute = false)
       raise '[BUG]' if pod_group(pod_name)
 
-      parent_group = development ? development_pods : pods
+      parent_group =
+        if pod_target_subproject
+          main_group
+        else
+          development ? development_pods : pods
+        end
       source_tree = absolute ? :absolute : :group
 
       group = parent_group.new_group(pod_name, path, source_tree)
@@ -111,7 +133,11 @@ module Pod
     # @return [Array<PBXGroup>] Returns all the group of the Pods.
     #
     def pod_groups
-      pods.children.objects + development_pods.children.objects
+      if pod_target_subproject
+        main_group.children.objects
+      else
+        pods.children.objects + development_pods.children.objects
+      end
     end
 
     # Returns the group for the Pod with the given name.
@@ -212,6 +238,37 @@ module Pod
       @refs_by_absolute_path[file_path_name.to_s] = ref
     end
 
+    # @!group File references
+    #-------------------------------------------------------------------------#
+
+    # Adds a file reference for a project as a child of the given group.
+    #
+    # @param  [Project] project
+    #         The project to add as a subproject reference.
+    #
+    # @param  [PBXGroup] group
+    #         The group for the new subproject reference.
+    #
+    # @return [PBXFileReference] The new file reference.
+    #
+    def add_subproject_reference(project, group)
+      new_subproject_file_reference(project.path, group)
+    end
+
+    # Adds a file reference for a cached project as a child of the given group.
+    #
+    # @param  [MetadataCache] metadata
+    #         The metadata holding the required properties to create a subproject reference.
+    #
+    # @param  [PBXGroup] group
+    #         The group for the new subproject reference.
+    #
+    # @return [PBXFileReference] The new file reference.
+    #
+    def add_cached_subproject_reference(metadata, group)
+      new_subproject_file_reference(metadata.container_project_path, group)
+    end
+
     # Returns the file reference for the given absolute path.
     #
     # @param  [#to_s] absolute_path
@@ -383,7 +440,7 @@ module Pod
     # Returns the name to be used for a the variant group for a file at a given path.
     # The path must be localized (within an *.lproj directory).
     #
-    # @param  [Pathname] The localized path to get a variant group name for.
+    # @param  [Pathname] path The localized path to get a variant group name for.
     #
     # @return [String] The variant group name.
     #
@@ -411,6 +468,27 @@ module Pod
       path.basename.to_s
     end
 
+    def new_subproject_file_reference(project_path, group)
+      if ref = reference_for_path(project_path)
+        return ref
+      end
+
+      # We call into the private function `FileReferencesFactory.new_file_reference` instead of `FileReferencesFactory.new_reference`
+      # because it delegates into `FileReferencesFactory.new_subproject` which has the extra behavior of opening the Project which
+      # is an expensive operation for large projects.
+      #
+      ref = Xcodeproj::Project::FileReferencesFactory.send(:new_file_reference, group, project_path, :group)
+      ref.name = Pathname(project_path).basename('.*').to_s
+      ref.include_in_index = nil
+
+      attribute = PBXProject.references_by_keys_attributes.find { |attrb| attrb.name == :project_references }
+      project_reference = ObjectDictionary.new(attribute, group.project.root_object)
+      project_reference[:project_ref] = ref
+      root_object.project_references << project_reference
+      refs_by_absolute_path[project_path.to_s] = ref
+      ref
+    end
+
     #-------------------------------------------------------------------------#
   end
 end