cocoapods 1.4.0 → 1.5.0.beta.1

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

@@ -81,11 +81,8 @@ module Pod
             end
 
             if target.requires_frameworks?
-              framework_name = target.product_module_name
-              settings['PRODUCT_NAME'] = framework_name
               if target.static_framework?
-                settings['PUBLIC_HEADERS_FOLDER_PATH'] = framework_name + '.framework' + '/Headers'
-                settings['PRIVATE_HEADERS_FOLDER_PATH'] = framework_name + '.framework' + '/PrivateHeaders'
+                settings['MACH_O_TYPE'] = 'staticlib'
               end
             else
               settings.merge!('OTHER_LDFLAGS' => '', 'OTHER_LIBTOOLFLAGS' => '')
@@ -105,6 +102,7 @@ module Pod
           # @return [Void]
           #
           def update_changed_file(generator, path)
+            path.dirname.mkpath
             if path.exist?
               generator.save_as(support_files_temp_dir)
               unless FileUtils.identical?(support_files_temp_dir, path)
@@ -169,9 +167,6 @@ module Pod
           # Creates the module map file which ensures that the umbrella header is
           # recognized with a customized path
           #
-          # @yield_param [Generator::ModuleMap]
-          #              yielded once to configure the private headers
-          #
           # @return [void]
           #
           def create_module_map
@@ -207,10 +202,10 @@ module Pod
               file_ref = add_file_to_support_group(path)
               native_target.add_file_references([file_ref])
 
-              # Make the umbrella header public
+              acl = target.requires_frameworks? ? 'Public' : 'Project'
               build_file = native_target.headers_build_phase.build_file(file_ref)
               build_file.settings ||= {}
-              build_file.settings['ATTRIBUTES'] = ['Public']
+              build_file.settings['ATTRIBUTES'] = [acl]
             end
           end
 

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

@@ -35,7 +35,7 @@ module Pod
           verify_no_duplicate_framework_and_library_names
           verify_no_static_framework_transitive_dependencies
           verify_no_pods_used_with_multiple_swift_versions
-          verify_framework_usage
+          verify_swift_pods_have_module_dependencies
         end
 
         private
@@ -71,16 +71,22 @@ module Pod
             next unless aggregate_target.requires_frameworks?
 
             aggregate_target.user_build_configurations.keys.each do |config|
-              pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
+              dynamic_pod_targets = aggregate_target.pod_targets_for_build_configuration(config).reject(&:static_framework?)
 
-              dependencies = pod_targets.select(&:should_build?).reject(&:static_framework?).flat_map(&:dependencies)
-              depended_upon_targets = pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
+              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? }
 
               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})"
               end
+
+              static_framework_deps = dynamic_pod_targets.select(&:should_build?).flat_map(&:recursive_dependent_targets).select(&:static_framework?)
+              unless static_framework_deps.empty?
+                raise Informative, "The '#{aggregate_target.label}' target has " \
+                  "transitive dependencies that include static frameworks: (#{static_framework_deps.flat_map(&:name).to_sentence})"
+              end
             end
           end
         end
@@ -100,26 +106,34 @@ module Pod
 
           unless error_messages.empty?
             raise Informative, 'The following pods are integrated into targets ' \
-            "that do not have the same Swift version:\n\n#{error_messages.join("\n")}"
+              "that do not have the same Swift version:\n\n#{error_messages.join("\n")}"
           end
         end
 
-        def verify_framework_usage
-          aggregate_targets.each do |aggregate_target|
-            next if aggregate_target.requires_frameworks?
-
-            aggregate_target.user_build_configurations.keys.each do |config|
-              pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
+        def verify_swift_pods_have_module_dependencies
+          error_messages = []
+          pod_targets.each do |pod_target|
+            next unless pod_target.uses_swift?
 
-              swift_pods = pod_targets.select(&:uses_swift?)
-              unless swift_pods.empty?
-                raise Informative, 'Pods written in Swift can only be integrated as frameworks; ' \
-                  'add `use_frameworks!` to your Podfile or target to opt into using it. ' \
-                  "The Swift #{swift_pods.size == 1 ? 'Pod being used is' : 'Pods being used are'}: " +
-                  swift_pods.map(&:name).to_sentence
-              end
+            non_module_dependencies = []
+            pod_target.dependent_targets.each do |dependent_target|
+              next if !dependent_target.should_build? || dependent_target.defines_module?
+              non_module_dependencies << dependent_target.name
             end
+
+            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. ' \
+                              '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, '\
+                              'or specify `:modular_headers => true` for particular dependencies.'
           end
+          return if error_messages.empty?
+
+          raise Informative, 'The following Swift pods cannot yet be integrated '\
+                             "as static libraries:\n\n#{error_messages.join("\n\n")}"
         end
       end
     end

data/lib/cocoapods/project.rb

@@ -40,6 +40,23 @@ module Pod
     #
     attr_reader :development_pods
 
+    # Generates a list of new UUIDs that created objects can be assigned.
+    #
+    # @note Overridden to generate UUIDs in a much faster way, since we don't need to check for collisions
+    #       (as the Pods project is regenerated each time, and thus all UUIDs will have come from this method)
+    #
+    # @param [Integer] count
+    #        The number of UUIDs to generate
+    #
+    # @return [Void]
+    #
+    def generate_available_uuid_list(count = 100)
+      start = @generated_uuids.size
+      uniques = Array.new(count) { |i| format('%011X0', start + i) }
+      @generated_uuids += uniques
+      @available_uuids += uniques
+    end
+
     public
 
     # @!group Legacy Xcode build root
@@ -185,15 +202,14 @@ module Pod
     # @return [PBXFileReference] The new file reference.
     #
     def add_file_reference(absolute_path, group, reflect_file_system_structure = false, base_path = nil)
-      file_path_name = absolute_path.is_a?(Pathname) ? absolute_path : Pathname.new(absolute_path)
-      group = group_for_path_in_group(file_path_name, group, reflect_file_system_structure, base_path)
-      if ref = reference_for_path(file_path_name.realpath)
-        @refs_by_absolute_path[absolute_path.to_s] = ref
-        ref
-      else
-        ref = group.new_file(file_path_name.realpath)
-        @refs_by_absolute_path[absolute_path.to_s] = ref
+      file_path_name = absolute_path.is_a?(Pathname) ? absolute_path : Pathname(absolute_path)
+      if ref = reference_for_path(file_path_name)
+        return ref
       end
+
+      group = group_for_path_in_group(file_path_name, group, reflect_file_system_structure, base_path)
+      ref = group.new_file(file_path_name.realpath)
+      @refs_by_absolute_path[file_path_name.to_s] = ref
     end
 
     # Returns the file reference for the given absolute path.
@@ -205,11 +221,12 @@ module Pod
     # @return [Nil] If no file reference could be found.
     #
     def reference_for_path(absolute_path)
-      unless Pathname.new(absolute_path).absolute?
+      absolute_path = absolute_path.is_a?(Pathname) ? absolute_path : Pathname(absolute_path)
+      unless absolute_path.absolute?
         raise ArgumentError, "Paths must be absolute #{absolute_path}"
       end
 
-      refs_by_absolute_path[absolute_path.to_s]
+      refs_by_absolute_path[absolute_path.to_s] ||= refs_by_absolute_path[absolute_path.realpath.to_s]
     end
 
     # Adds a file reference to the Podfile.
@@ -336,28 +353,26 @@ module Pod
       relative_base = base_path.nil? ? group.real_path : base_path.realdirpath
       relative_pathname = absolute_pathname.relative_path_from(relative_base)
       relative_dir = relative_pathname.dirname
-      lproj_regex = /\.lproj/i
 
       # Add subgroups for directories, but treat .lproj as a file
       if reflect_file_system_structure
         path = relative_base
         relative_dir.each_filename do |name|
-          break if name.to_s =~ lproj_regex
+          break if name.to_s.downcase.include? '.lproj'
           next if name == '.'
           # Make sure groups have the correct absolute path set, as intermittent
           # directories may not be included in the group structure
           path += name
-          group = group[name] || group.new_group(name, path)
+          group = group.children.find { |c| c.display_name == name } || group.new_group(name, path)
         end
       end
 
       # Turn files inside .lproj directories into a variant group
-      if relative_dir.basename.to_s =~ lproj_regex
+      if relative_dir.basename.to_s.downcase.include? '.lproj'
         group_name = variant_group_name(absolute_pathname)
         lproj_parent_dir = absolute_pathname.dirname.dirname
-        group = @variant_groups_by_path_and_name[[lproj_parent_dir, group_name]] ||
-          group.new_variant_group(group_name, lproj_parent_dir)
-        @variant_groups_by_path_and_name[[lproj_parent_dir, group_name]] ||= group
+        group = @variant_groups_by_path_and_name[[lproj_parent_dir, group_name]] ||=
+                  group.new_variant_group(group_name, lproj_parent_dir)
       end
 
       group

data/lib/cocoapods/resolver.rb

@@ -20,14 +20,19 @@ module Pod
       #
       attr_reader :spec
 
+      # @return [Source] the spec repo source the specification came from
+      #
+      attr_reader :source
+
       # @return [Bool] whether this resolved specification is only used by tests.
       #
       attr_reader :used_by_tests_only
       alias used_by_tests_only? used_by_tests_only
 
-      def initialize(spec, used_by_tests_only)
+      def initialize(spec, used_by_tests_only, source)
         @spec = spec
         @used_by_tests_only = used_by_tests_only
+        @source = source
       end
 
       def name
@@ -66,11 +71,11 @@ module Pod
     # @return [Array<Source>] The list of the sources which will be used for
     #         the resolution.
     #
-    attr_accessor :sources
+    attr_reader :sources
 
     # @return [Bool] Whether the resolver has sources repositories up-to-date.
     #
-    attr_accessor :specs_updated
+    attr_reader :specs_updated
     alias specs_updated? specs_updated
 
     # Init a new Resolver
@@ -79,12 +84,18 @@ module Pod
     # @param  [Podfile] podfile @see podfile
     # @param  [Array<Dependency>] locked_dependencies @see locked_dependencies
     # @param  [Array<Source>, Source] sources @see sources
+    # @param  [Boolean] specs_updated @see specs_updated
+    # @param  [PodfileDependencyCache] podfile_dependency_cache the podfile dependency cache to use
+    #         within this Resolver.
     #
-    def initialize(sandbox, podfile, locked_dependencies, sources)
+    def initialize(sandbox, podfile, locked_dependencies, sources, specs_updated,
+                   podfile_dependency_cache: Installer::Analyzer::PodfileDependencyCache.from_podfile(podfile))
       @sandbox = sandbox
       @podfile = podfile
       @locked_dependencies = locked_dependencies
       @sources = Array(sources)
+      @specs_updated = specs_updated
+      @podfile_dependency_cache = podfile_dependency_cache
       @platforms_by_dependency = Hash.new { |h, k| h[k] = [] }
       @cached_sets = {}
     end
@@ -102,11 +113,13 @@ module Pod
     #         definition.
     #
     def resolve
-      dependencies = podfile.target_definition_list.flat_map do |target|
-        target.dependencies.each do |dep|
-          @platforms_by_dependency[dep].push(target.platform).uniq! if target.platform
+      dependencies = @podfile_dependency_cache.target_definition_list.flat_map do |target|
+        @podfile_dependency_cache.target_definition_dependencies(target).each do |dep|
+          next unless target.platform
+          @platforms_by_dependency[dep].push(target.platform)
         end
       end
+      @platforms_by_dependency.each_value(&:uniq!)
       @activated = Molinillo::Resolver.new(self, self).resolve(dependencies, locked_dependencies)
       resolver_specs_by_target
     rescue Molinillo::ResolverError => e
@@ -120,16 +133,22 @@ module Pod
     #
     def resolver_specs_by_target
       @resolver_specs_by_target ||= {}.tap do |resolver_specs_by_target|
-        podfile.target_definition_list.each do |target|
-          dependencies = {}
-          specs = target.dependencies.map(&:name).flat_map do |name|
+        dependencies = {}
+        @podfile_dependency_cache.target_definition_list.each do |target|
+          specs = @podfile_dependency_cache.target_definition_dependencies(target).flat_map do |dep|
+            name = dep.name
             node = @activated.vertex_named(name)
             (valid_dependencies_for_target_from_node(target, dependencies, node) << node).map { |s| [s, node.payload.test_specification?] }
           end
 
           resolver_specs_by_target[target] = specs.
             group_by(&:first).
-            map { |vertex, spec_test_only_tuples| ResolverSpecification.new(vertex.payload, spec_test_only_tuples.map { |tuple| tuple[1] }.all?) }.
+            map do |vertex, spec_test_only_tuples|
+              test_only = spec_test_only_tuples.all? { |tuple| tuple[1] }
+              payload = vertex.payload
+              spec_source = payload.respond_to?(:spec_source) && payload.spec_source
+              ResolverSpecification.new(payload, test_only, spec_source)
+            end.
             sort_by(&:name)
         end
       end
@@ -153,7 +172,9 @@ module Pod
     def search_for(dependency)
       @search ||= {}
       @search[dependency] ||= begin
-        specifications_for_dependency(dependency, [requirement_for_locked_pod_named(dependency.name)])
+        locked_requirement = requirement_for_locked_pod_named(dependency.name)
+        additional_requirements = Array(locked_requirement)
+        specifications_for_dependency(dependency, additional_requirements)
       end
       @search[dependency].dup
     end
@@ -327,7 +348,7 @@ module Pod
     #         one Pod installation, so different version of the same Pods for
     #         target definitions are not allowed.
     #
-    attr_accessor :cached_sets
+    attr_reader :cached_sets
 
     #-------------------------------------------------------------------------#
 
@@ -347,7 +368,7 @@ module Pod
     # @return [Array<Specification>] List of specifications satisfying given requirements.
     #
     def specifications_for_dependency(dependency, additional_requirements = [])
-      requirement = Requirement.new(dependency.requirement.as_list + additional_requirements)
+      requirement = Requirement.new(dependency.requirement.as_list + additional_requirements.flat_map(&:as_list))
       find_cached_set(dependency).
         all_specifications(installation_options.warn_for_multiple_pod_sources).
         select { |s| requirement.satisfied_by? s.version }.
@@ -477,7 +498,7 @@ module Pod
               # Conflict was caused by not specifying an explicit version for the requirement #[name],
               # and there is no available stable version satisfying constraints for the requirement.
               o << "\nThere are only pre-release versions available satisfying the following requirements:\n"
-              conflict.requirements.values.flatten.each do |r|
+              conflict.requirements.values.flatten.uniq.each do |r|
                 unless search_for(r).empty?
                   o << "\n\t'#{name}', '#{r.requirement}'\n"
                 end
@@ -525,11 +546,15 @@ module Pod
       vertex = dependency_graph.vertex_named(dependency.name)
       predecessors = vertex.recursive_predecessors.select(&:root)
       predecessors << vertex if vertex.root?
-      platforms_to_satisfy = predecessors.flat_map(&:explicit_requirements).flat_map { |r| @platforms_by_dependency[r] }
+      platforms_to_satisfy = predecessors.flat_map(&:explicit_requirements).flat_map { |r| @platforms_by_dependency[r] }.uniq
+
+      available_platforms = spec.available_platforms
 
       platforms_to_satisfy.all? do |platform_to_satisfy|
-        spec.available_platforms.select { |spec_platform| spec_platform.name == platform_to_satisfy.name }.
-          all? { |spec_platform| platform_to_satisfy.supports?(spec_platform) }
+        available_platforms.all? do |spec_platform|
+          next true unless spec_platform.name == platform_to_satisfy.name
+          platform_to_satisfy.supports?(spec_platform)
+        end
       end
     end
 
@@ -542,28 +567,31 @@ module Pod
     #         dependencies for `target`.
     #
     def valid_dependencies_for_target_from_node(target, dependencies, node)
-      dependencies[node.name] ||= begin
+      dependencies[[node.name, target.platform]] ||= begin
         validate_platform(node.payload, target)
-        dependency_nodes = node.outgoing_edges.select do |edge|
-          edge_is_valid_for_target?(edge, target)
-        end.map(&:destination)
-
-        dependency_nodes + dependency_nodes.flat_map do |item|
-          node_result = valid_dependencies_for_target_from_node(target, dependencies, item)
-          node_result
+        dependency_nodes = []
+        node.outgoing_edges.each do |edge|
+          next unless edge_is_valid_for_target_platform?(edge, target.platform)
+          dependency_nodes << edge.destination
         end
+
+        dependency_nodes.flat_map do |item|
+          valid_dependencies_for_target_from_node(target, dependencies, item)
+        end.concat dependency_nodes
       end
     end
 
     # Whether the given `edge` should be followed to find dependencies for the
-    # given `target`.
+    # given `target_platform`.
     #
     # @return [Bool]
     #
-    def edge_is_valid_for_target?(edge, target)
-      dependencies_for_target_platform =
-        edge.origin.payload.all_dependencies(target.platform).map(&:name)
-      dependencies_for_target_platform.include?(edge.requirement.name)
+    def edge_is_valid_for_target_platform?(edge, target_platform)
+      requirement_name = edge.requirement.name
+
+      edge.origin.payload.all_dependencies(target_platform).any? do |dep|
+        dep.name == requirement_name
+      end
     end
   end
 end

data/lib/cocoapods/resolver/lazy_specification.rb

@@ -1,34 +1,44 @@
+require 'delegate'
 module Pod
   class Specification
     class Set
-      class LazySpecification < BasicObject
-        attr_reader :name, :version, :source
-
-        def initialize(name, version, source)
-          @name = name
-          @version = version
-          @source = source
+      class SpecWithSource < DelegateClass(Specification)
+        attr_reader :spec_source
+        def initialize(spec, source)
+          super(spec)
+          @spec_source = source
         end
 
-        def method_missing(method, *args, &block)
-          specification.send(method, *args, &block)
-        end
+        undef is_a?
+      end
+
+      class LazySpecification < DelegateClass(Specification)
+        attr_reader :name, :version, :spec_source
 
-        def respond_to_missing?(method, include_all = false)
-          specification.respond_to?(method, include_all)
+        def initialize(name, version, spec_source)
+          @name = name
+          @version = version
+          @spec_source = spec_source
         end
 
         def subspec_by_name(name = nil, raise_if_missing = true, include_test_specifications = false)
-          if !name || name == self.name
-            self
-          else
-            specification.subspec_by_name(name, raise_if_missing, include_test_specifications)
-          end
+          subspec =
+            if !name || name == self.name
+              self
+            else
+              specification.subspec_by_name(name, raise_if_missing, include_test_specifications)
+            end
+          return unless subspec
+
+          SpecWithSource.new subspec, spec_source
         end
 
         def specification
-          @specification ||= source.specification(name, version.version)
+          @specification ||= spec_source.specification(name, version.version)
         end
+        alias __getobj__ specification
+
+        undef is_a?
       end
 
       class External